@amritk/generate-parsers 0.12.2 → 0.13.0

package/dist/generators/generate-strict-assertion.js

@@ -1,7 +1,11 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { multipleOfFailExpr } from '@amritk/helpers/multiple-of-check';
 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 { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { generateEnumCheck } from './generate-enum-check.js';
+import { canEnforceUnion, generateUnionCheck, getUnionBranches } from './generate-type-checks.js';
+import { scalarItemTypeCheck } from './generate-validation-expression.js';
 /**
  * Returns the inline condition that is true when `accessor` is the wrong type
  * for the given JSON Schema primitive type.
@@ -11,8 +15,10 @@ const wrongTypeCondition = (accessor, type) => {
         case 'string':
             return `typeof ${accessor} !== "string"`;
         case 'number':
-        case 'integer':
             return `typeof ${accessor} !== "number"`;
+        case 'integer':
+            // `integer` also rejects non-integral numbers; a bare typeof accepts `1.5`.
+            return `(typeof ${accessor} !== "number" || !Number.isInteger(${accessor}))`;
         case 'boolean':
             return `typeof ${accessor} !== "boolean"`;
         case 'array':
@@ -28,6 +34,18 @@ const wrongTypeCondition = (accessor, type) => {
  * `integer` collapses to `number` since both are validated via `typeof === "number"`.
  */
 const typeLabel = (type) => (type === 'integer' ? 'number' : type);
+/**
+ * Emits `throw new Error(<message>[ + <suffixExpr>])`. The static message may
+ * contain schema-controlled text (property names, patterns, enum values), so it
+ * is always serialized with `JSON.stringify` — a key like `it's` or a pattern
+ * containing a quote or newline can no longer break out of the string literal or
+ * inject code. `suffixExpr`, when given, is a runtime expression appended to the
+ * message (e.g. `typeof input`).
+ */
+const throwError = (message, suffixExpr) => {
+    const literal = JSON.stringify(message);
+    return suffixExpr ? `throw new Error(${literal} + (${suffixExpr}))` : `throw new Error(${literal})`;
+};
 /**
  * Generates strict-mode constraint checks for a typed property
  * (pattern, length, min/max, multipleOf).
@@ -37,69 +55,125 @@ const generateConstraintChecks = (acc, propSchema, typeName, key) => {
         return [];
     const t = propSchema.type;
     const lines = [];
+    const field = `[${typeName}] field '${key}'`;
     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}');`);
+            lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) ${throwError(`${field} 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');`);
+            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) ${throwError(`${field} 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');`);
+            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) ${throwError(`${field} 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}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) ${throwError(`${field} 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}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) ${throwError(`${field} 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}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) ${throwError(`${field} 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}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) ${throwError(`${field} 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}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);
+        }
+    }
+    if (t === 'array') {
+        if (hasMinItems(propSchema)) {
+            lines.push(`  if (Array.isArray(${acc}) && ${acc}.length < ${propSchema.minItems}) ${throwError(`${field} must have at least ${propSchema.minItems} items`)};`);
+        }
+        if (hasMaxItems(propSchema)) {
+            lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${propSchema.maxItems}) ${throwError(`${field} must have at most ${propSchema.maxItems} items`)};`);
+        }
+        if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
+            // Deep-equality dedupe via JSON keys, matching the interpreter's semantics —
+            // a plain `new Set` would only catch primitive duplicates, not equal objects.
+            lines.push(`  if (Array.isArray(${acc}) && new Set(${acc}.map((_u) => JSON.stringify(_u))).size !== ${acc}.length) ${throwError(`${field} must NOT have duplicate items`)};`);
+        }
+        // Item types: the fast path proves them via `.every`, but this slow path
+        // used to check only length/uniqueness, letting e.g. a number slip into a
+        // declared `string[]`. Enforce scalar and enum item schemas here; richer
+        // item schemas ($refs, objects) are validated by their own parsers.
+        const itemCheck = generateItemCheck(propSchema);
+        if (itemCheck) {
+            lines.push(`  if (Array.isArray(${acc}) && !${acc}.every((_it) => ${itemCheck.check})) ${throwError(`${field} ${itemCheck.message}`)};`);
         }
     }
     return lines;
 };
+/**
+ * Boolean per-item check (bound to `_it`) for an array schema's `items`, with
+ * the error-message fragment describing what was expected. Only scalar types
+ * and enums are checked — returns null for anything richer.
+ */
+const generateItemCheck = (schema) => {
+    if (!isSchemaObject(schema) || !hasItems(schema) || Array.isArray(schema.items))
+        return null;
+    const items = schema.items;
+    if (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0) {
+        const label = items.enum.map((v) => JSON.stringify(v)).join(', ');
+        return { check: generateEnumCheck('_it', items.enum), message: `items must be one of: ${label}` };
+    }
+    const scalarCheck = scalarItemTypeCheck(items, '_it');
+    if (scalarCheck === null || !isSchemaObject(items) || !hasType(items))
+        return null;
+    return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
+};
 /**
  * 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, propSchema, isRequired, typeName) => {
+const generatePropertyAssertion = (key, propSchema, isRequired, typeName, context = {}) => {
     const acc = safeAccessor('input', key);
+    const field = `[${typeName}] field '${key}'`;
     const lines = [];
     if (isRequired) {
-        lines.push(`  if (!(${JSON.stringify(key)} in input)) throw new Error('[${typeName}] missing required property "${key}"');`);
+        lines.push(`  if (!(${JSON.stringify(key)} in input)) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
     }
     if (!isSchemaObject(propSchema))
         return lines;
     if (hasRef(propSchema))
         return lines;
+    // Union properties: enforce membership when every branch check is
+    // false-sound (canEnforceUnion), so a value matching no variant throws
+    // instead of passing through untyped. Left unenforced (pass-through, the
+    // historical behavior) when any branch is too complex to check safely.
+    const unionBranches = getUnionBranches(propSchema);
+    if (unionBranches) {
+        if (!context.stripUnknown && canEnforceUnion(unionBranches, context.rootSchema)) {
+            const check = generateUnionCheck(acc, unionBranches, context.useRefImports ?? false, context.suffix ?? '');
+            if (check !== null) {
+                const failure = throwError(`${field} does not match any allowed variant`);
+                lines.push(isRequired ? `  if (!(${check})) ${failure};` : `  if (${acc} !== undefined && !(${check})) ${failure};`);
+            }
+        }
+        return lines;
+    }
     const instanceOf = getMjstInstanceOf(propSchema);
     if (instanceOf) {
         if (isRequired) {
-            lines.push(`  if (!(${acc} instanceof ${instanceOf})) throw new Error('[${typeName}] field "${key}" must be ${instanceOf}');`);
+            lines.push(`  if (!(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
         }
         else {
-            lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) throw new Error('[${typeName}] field "${key}" must be ${instanceOf}');`);
+            lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
         }
         return lines;
     }
     const primitive = getMjstPrimitive(propSchema);
     if (primitive) {
         if (isRequired) {
-            lines.push(`  if (typeof ${acc} !== "${primitive}") throw new Error('[${typeName}] field "${key}" must be ${primitive}');`);
+            lines.push(`  if (typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
         }
         else {
-            lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") throw new Error('[${typeName}] field "${key}" must be ${primitive}');`);
+            lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
         }
         return lines;
     }
@@ -107,10 +181,10 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
         const allowed = JSON.stringify(propSchema.enum);
         const label = propSchema.enum.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}');`);
+            lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} 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}');`);
+            lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
         }
         return lines;
     }
@@ -118,11 +192,12 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
         const t = propSchema.type;
         const wrongType = wrongTypeCondition(acc, t);
         if (wrongType) {
+            const expected = throwError(`${field} expected ${typeLabel(t)}, got `, `typeof ${acc}`);
             if (isRequired) {
-                lines.push(`  if (${wrongType}) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+                lines.push(`  if (${wrongType}) ${expected};`);
             }
             else {
-                lines.push(`  if (${acc} !== undefined && (${wrongType})) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+                lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
             }
         }
         lines.push(...generateConstraintChecks(acc, propSchema, typeName, key));
@@ -140,14 +215,14 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
  * Properties with a `$ref` are validated by the nested parser's own strict
  * check when that parser is invoked downstream.
  */
-export const generateObjectStrictAssertion = (schema, typeName) => {
+export const generateObjectStrictAssertion = (schema, typeName, context = {}) => {
     const lines = [];
-    lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
+    lines.push(`  if (!isObject(input)) ${throwError(`[${typeName}] expected object, got `, 'input === null ? "null" : typeof input')};`);
     if (!hasProperties(schema) || !isSchemaObject(schema))
         return lines;
     const required = new Set(hasRequired(schema) ? schema.required : []);
     for (const [key, propSchema] of Object.entries(schema.properties)) {
-        lines.push(...generatePropertyAssertion(key, propSchema, required.has(key), typeName));
+        lines.push(...generatePropertyAssertion(key, propSchema, required.has(key), typeName, context));
     }
     return lines;
 };
@@ -156,13 +231,14 @@ export const generateObjectStrictAssertion = (schema, typeName) => {
  * Returns null when the schema has no type information to assert on.
  */
 export const generateScalarStrictAssertion = (schema, typeName) => {
+    const got = 'input === null ? "null" : typeof input';
     const instanceOf = getMjstInstanceOf(schema);
     if (instanceOf) {
-        return `  if (!(input instanceof ${instanceOf})) throw new Error(\`[${typeName}] expected ${instanceOf}, got \${input === null ? "null" : typeof input}\`);`;
+        return `  if (!(input instanceof ${instanceOf})) ${throwError(`[${typeName}] expected ${instanceOf}, got `, got)};`;
     }
     const primitive = getMjstPrimitive(schema);
     if (primitive) {
-        return `  if (typeof input !== "${primitive}") throw new Error(\`[${typeName}] expected ${primitive}, got \${input === null ? "null" : typeof input}\`);`;
+        return `  if (typeof input !== "${primitive}") ${throwError(`[${typeName}] expected ${primitive}, got `, got)};`;
     }
     if (!isSchemaObject(schema) || !hasType(schema))
         return null;
@@ -170,5 +246,14 @@ export const generateScalarStrictAssertion = (schema, typeName) => {
     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}\`);`;
+    const lines = [`  if (${wrongType}) ${throwError(`[${typeName}] expected ${typeLabel(t)}, got `, got)};`];
+    // Root-level arrays enforce scalar/enum item types too — the same gap the
+    // property path closes in generateConstraintChecks.
+    if (t === 'array') {
+        const itemCheck = generateItemCheck(schema);
+        if (itemCheck) {
+            lines.push(`  if (!(input as readonly unknown[]).every((_it) => ${itemCheck.check})) ${throwError(`[${typeName}] ${itemCheck.message}`)};`);
+        }
+    }
+    return lines.join('\n');
 };

package/dist/generators/generate-type-checks.d.ts

@@ -0,0 +1,65 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Boolean type-check expression builders shared by the shape validators, the
+ * parsers' fast paths, and the strict-mode assertions. They live in their own
+ * module (rather than generate-parser-function) so generate-strict-assertion
+ * can use them without an import cycle.
+ *
+ * Every expression built here is *true-sound*: when it evaluates to true the
+ * value definitely matches the schema fragment. That is all a fast path needs.
+ * The reverse direction — false definitely means invalid — only holds when
+ * {@link canEnforceUnion} approves the schema, because a check may call an
+ * imported `validate{X}Shape` that was generated as a conservative `=> false`
+ * stub. Strict-mode code that *throws* on a false check must gate on it.
+ */
+/**
+ * Returns the shape-predicate function name for a given type name.
+ * The predicate is generated alongside each parser and tells callers
+ * whether `input` is already in the shape produced by the parser's fast path.
+ */
+export declare const shapeValidatorName: (typeName: string) => string;
+/**
+ * Extracts the branch list of a `oneOf`/`anyOf` union, or `null` when the
+ * schema is not a union (or mixes in other composition keywords we cannot
+ * turn into a membership check).
+ */
+export declare const getUnionBranches: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * Generates a fast-path type check expression for a property.
+ * Returns null if the schema is too complex for a simple type check.
+ *
+ * When `useRefImports` is true, $ref properties (and arrays of $refs) are
+ * checked by calling the imported shape predicate, allowing parent parsers
+ * to fast-path through nested ref types without recursing into their parsers.
+ */
+export declare const generatePropertyTypeCheck: (varName: string, schema: JSONSchema, useRefImports: boolean, suffix: string) => string | null;
+/**
+ * Generates a boolean check that `varName` matches an inline object schema —
+ * `isObject` plus a per-property check for every declared property (and a
+ * presence check for `required` keys without a declared schema). Used for
+ * union branches written inline, where no named shape validator exists to
+ * call. Returns null when any property is too complex to check.
+ */
+export declare const generateInlineObjectCheck: (varName: string, schema: JSONSchema, useRefImports: boolean, suffix: string) => string | null;
+/**
+ * Generates a union membership check: true when `varName` matches at least one
+ * branch of a `oneOf`/`anyOf`. Inline object branches get a per-property check;
+ * everything else goes through {@link generatePropertyTypeCheck} ($refs call
+ * the imported shape validator, consts/enums/scalars check directly). Returns
+ * null when any branch cannot be checked.
+ */
+export declare const generateUnionCheck: (varName: string, branches: readonly JSONSchema[], useRefImports: boolean, suffix: string) => string | null;
+/**
+ * True when the union membership check emitted by {@link generateUnionCheck}
+ * is also *false-sound* — a false result definitely means the value is invalid
+ * — so strict mode may throw on it.
+ *
+ * The risk is `$ref`s: a branch (or a property inside one) whose check calls
+ * an imported `validate{X}Shape` is only trustworthy when that validator was
+ * generated as a real predicate. This walks every reachable ref (mirroring
+ * generateShapeValidator's stub conditions) and rejects the union when any of
+ * them would have produced the conservative `=> false` stub, or is itself
+ * built on one. Cycles (e.g. a recursive `expr` union) are assumed sound —
+ * the recursion bottoms out on the data, not the schema.
+ */
+export declare const canEnforceUnion: (branches: readonly JSONSchema[], rootSchema: Record<string, unknown> | undefined) => boolean;