@amritk/generate-parsers 0.18.0 → 0.19.0

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

@@ -41,13 +41,26 @@ export declare const isInlineObjectArrayProperty: (propSchema: JSONSchema) => bo
  * turn into a membership check).
  */
 export declare const getUnionBranches: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * True when {@link getUnionBranches} came from a `oneOf` rather than an `anyOf` —
+ * i.e. the value must match *exactly one* branch, not at least one.
+ *
+ * The distinction was dropped before: both spellings produced a plain
+ * disjunction, so `{ oneOf: [{…a}, {…b}] }` accepted `{ a: 'x', b: 1 }`, which
+ * matches both branches. Ajv, the runtime interpreter, and `generate-validators`
+ * all reject it, so the two mjst engines disagreed on the same contract.
+ */
+export declare const isExclusiveUnion: (schema: JSONSchema) => boolean;
 /**
  * True when a schema carries a keyword the strict slow path enforces but which
  * no flat type check can mirror: `contains` (array item counting),
- * `dependentRequired` / `dependentSchemas` (cross-property presence), or
- * `propertyNames` (per-key constraints). A fast path or shape validator that
- * accepted such a value on a bare type check would skip the enforcement, so
- * both must bail when this is true — the slow path then runs the real checks.
+ * `dependentRequired` / `dependentSchemas` (cross-property presence),
+ * `propertyNames` (per-key constraints), the conditional and composition
+ * keywords (`if`/`then`/`else`, `not`, a constraining `allOf`), or per-key value
+ * schemas (`patternProperties`, a constraining `additionalProperties`). A fast
+ * path or shape validator that accepted such a value on a bare type check would
+ * skip the enforcement, so both must bail when this is true — the slow path then
+ * runs the real checks.
  */
 export declare const hasFastPathBlockingKeyword: (schema: JSONSchema) => boolean;
 /**
@@ -83,13 +96,21 @@ export declare const generatePropertyTypeCheck: (varName: string, schema: JSONSc
  */
 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.
+ * Generates a union membership check. 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.
+ *
+ * `exclusive` (a `oneOf` — see {@link isExclusiveUnion}) counts the matching
+ * branches and demands exactly one, instead of the `anyOf` disjunction. The count
+ * form is *tighter* than the disjunction it replaces — anything it accepts, the
+ * disjunction accepted too — so a true-sound caller (a fast path, a shape
+ * validator) can only get safer: a value it now declines merely takes the slow
+ * path, which re-validates. A caller that *throws* on a false result needs each
+ * branch check to be exact in both directions, which is precisely what
+ * {@link canEnforceUnion} certifies.
  */
-export declare const generateUnionCheck: (varName: string, branches: readonly JSONSchema[], useRefImports: boolean, suffix: string) => string | null;
+export declare const generateUnionCheck: (varName: string, branches: readonly JSONSchema[], useRefImports: boolean, suffix: string, exclusive?: boolean) => 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

package/dist/generators/generate-type-checks.js

@@ -1,11 +1,13 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { safeAccessor } from "@amritk/helpers/safe-accessor";
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { generateEnumCheck } from "./generate-enum-check.js";
-import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck, singleTypeCheck } from "./generate-validation-expression.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
+import { everyTailItem, getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck, singleTypeCheck } from "./generate-validation-expression.js";
+import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
 const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
 const isInlineObjectProperty = (propSchema) => {
   if (!isSchemaObject(propSchema))
@@ -44,11 +46,30 @@ const getUnionBranches = (schema) => {
     return schema.anyOf;
   return null;
 };
+const isExclusiveUnion = (schema) => isSchemaObject(schema) && !hasAllOf(schema) && !("not" in schema) && hasOneOf(schema) && schema.oneOf.length > 0;
 const hasFastPathBlockingKeyword = (schema) => {
   if (!isSchemaObject(schema))
     return false;
   const record = schema;
-  return "contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record;
+  return "contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record || // Composition and conditionals: the strict assertions now enforce these, but
+  // a guard built from per-property type checks cannot mirror them — it said
+  // "already in shape" for `{ kind: 'a' }` under `if: {kind: 'a'}, then:
+  // {required: ['n']}` and returned before the conditional was ever tested.
+  "if" in record || "then" in record || "else" in record || "not" in record || "patternProperties" in record || // `unevaluated*` is answered against the whole node's annotation coverage,
+  // which a per-property guard has no way to reproduce.
+  "unevaluatedProperties" in record && record["unevaluatedProperties"] !== true || "unevaluatedItems" in record && record["unevaluatedItems"] !== true || // A `$ref` guard calls the target's shape validator, which knows nothing
+  // about the siblings 2020-12 still applies: `{ $ref: …, minProperties: 2 }`
+  // was waved through on the target's shape alone.
+  hasConstrainingRefSibling(schema) || hasConstrainingAllOf(schema) || hasConstrainingAdditionalProperties(schema);
+};
+const hasConstrainingAllOf = (schema) => hasAllOf(schema) && schema.allOf.some((member) => !(isSchemaObject(member) && hasRef(member)));
+const hasConstrainingAdditionalProperties = (schema) => {
+  if (!hasAdditionalProperties(schema))
+    return false;
+  const additional = schema.additionalProperties;
+  if (typeof additional === "boolean")
+    return false;
+  return subschemaMatchExpr("_x", additional) !== "true";
 };
 const CONSTRAINT_KEYWORDS = [
   "pattern",
@@ -91,10 +112,8 @@ const multiTypeCheck = (varName, schema, options = {}) => {
 const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   if (!isSchemaObject(schema))
     return null;
-  const record = schema;
-  if ("contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record) {
+  if (hasFastPathBlockingKeyword(schema))
     return null;
-  }
   if (useRefImports && hasRef(schema)) {
     const refName = refToName(schema.$ref, suffix);
     return `${shapeValidatorName(refName)}(${varName})`;
@@ -106,7 +125,7 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   }
   const branches = getUnionBranches(schema);
   if (branches) {
-    return generateUnionCheck(varName, branches, useRefImports, suffix);
+    return generateUnionCheck(varName, branches, useRefImports, suffix, isExclusiveUnion(schema));
   }
   if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema) {
     return null;
@@ -129,7 +148,7 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
     case "string": {
       checks.push(`typeof ${varName} === "string"`);
       if (hasPattern(schema))
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
+        checks.push(`${regexLiteral(schema.pattern)}.test(${varName})`);
       if (hasMinLength(schema))
         checks.push(`${varName}.length >= ${schema.minLength}`);
       if (hasMaxLength(schema))
@@ -163,13 +182,20 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
       if (hasMaxItems(schema))
         checks.push(`${varName}.length <= ${schema.maxItems}`);
       if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(`new Set(${varName}).size === ${varName}.length`);
+        checks.push(generateUniqueItemsCheck(varName, schema));
       }
       if (hasItems(schema) && !Array.isArray(schema.items)) {
         const items = schema.items;
         const itemCheck = scalarItemTypeCheck(items, "_it") ?? (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0 ? generateEnumCheck("_it", items.enum) : null);
-        if (itemCheck)
-          checks.push(`${varName}.every((_it) => ${itemCheck})`);
+        if (itemCheck) {
+          checks.push(everyTailItem(varName, itemCheck, schema));
+        } else if (!(isSchemaObject(items) && (hasRef(items) || isInlineObjectProperty(items)))) {
+          const match = subschemaMatchExpr("_it", items);
+          if (match === null)
+            return null;
+          if (match !== "true")
+            checks.push(everyTailItem(varName, match, schema));
+        }
       }
       const prefix = getPrefixItems(schema);
       if (prefix) {
@@ -186,6 +212,10 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
     }
     case "object":
       checks.push(`isObject(${varName})`);
+      if (hasMinProperties(schema))
+        checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);
+      if (hasMaxProperties(schema))
+        checks.push(`Object.keys(${varName}).length <= ${schema.maxProperties}`);
       break;
     default:
       return null;
@@ -218,15 +248,19 @@ const generateInlineObjectCheck = (varName, schema, useRefImports, suffix) => {
     required.delete(key);
   }
   for (const key of required) {
-    checks.push(`${JSON.stringify(key)} in ${varName}`);
+    checks.push(hasOwnCheck(varName, key));
   }
   if (hasAdditionalProperties(schema) && schema.additionalProperties === false) {
     const allowedKeys = JSON.stringify(Object.keys(schema.properties));
     checks.push(`Object.keys(${varName}).every((_k) => ${allowedKeys}.includes(_k))`);
   }
+  if (hasMinProperties(schema))
+    checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);
+  if (hasMaxProperties(schema))
+    checks.push(`Object.keys(${varName}).length <= ${schema.maxProperties}`);
   return checks.join(" && ");
 };
-const generateUnionCheck = (varName, branches, useRefImports, suffix) => {
+const generateUnionCheck = (varName, branches, useRefImports, suffix, exclusive = false) => {
   if (branches.length === 0)
     return null;
   const parts = [];
@@ -238,7 +272,11 @@ const generateUnionCheck = (varName, branches, useRefImports, suffix) => {
       return null;
     parts.push(`(${check})`);
   }
-  return parts.length === 1 ? parts[0] : `(${parts.join(" || ")})`;
+  if (parts.length === 1)
+    return parts[0];
+  if (exclusive)
+    return `((${parts.map((part) => `(${part} ? 1 : 0)`).join(" + ")}) === 1)`;
+  return `(${parts.join(" || ")})`;
 };
 const canEnforceUnion = (branches, rootSchema) => {
   const visiting = /* @__PURE__ */ new Set();
@@ -302,6 +340,13 @@ const canTrustShapeProperty = (propSchema, rootSchema, visiting) => {
   }
   return canTrustPropertyCheck(propSchema, rootSchema, visiting);
 };
+const KEYWORDS_INLINE_CHECK_IGNORES = [
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas",
+  "contains",
+  "unevaluatedProperties"
+];
 const canTrustInlineObjectCheck = (schema, rootSchema, visiting) => {
   if (!isSchemaObject(schema) || !isObjectSchema(schema) || !hasProperties(schema))
     return false;
@@ -311,6 +356,9 @@ const canTrustInlineObjectCheck = (schema, rootSchema, visiting) => {
     return false;
   if (hasAdditionalProperties(schema) && typeof schema.additionalProperties !== "boolean")
     return false;
+  const record = schema;
+  if (KEYWORDS_INLINE_CHECK_IGNORES.some((keyword) => keyword in record))
+    return false;
   return Object.values(schema.properties).every((propSchema) => canTrustPropertyCheck(propSchema, rootSchema, visiting));
 };
 const canTrustReferencedValidator = (ref, rootSchema, visiting) => {
@@ -353,6 +401,7 @@ export {
   generateUnionCheck,
   getUnionBranches,
   hasFastPathBlockingKeyword,
+  isExclusiveUnion,
   isInlineObjectArrayProperty,
   isInlineObjectProperty,
   multiTypeCheck,

package/dist/generators/generate-unique-items-check.d.ts

@@ -0,0 +1,16 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Builds the boolean expression that is TRUE when every element of `accessor` is
+ * distinct — the `uniqueItems: true` contract.
+ *
+ * Scalar-only arrays take the cheap native `Set` (exact for primitives, and
+ * allocation is a single pass). Anything that might hold an object or an array
+ * falls back to the canonical-JSON projection above, because JSON Schema compares
+ * items by *structural* equality and neither a plain `Set` (reference equality)
+ * nor a raw `JSON.stringify` key (order sensitive) answers that question.
+ *
+ * @param accessor - Expression yielding the array; the caller must already have
+ *   proven `Array.isArray`.
+ * @param schema - The array schema, read for its item types.
+ */
+export declare const generateUniqueItemsCheck: (accessor: string, schema: JSONSchema) => string;

package/dist/generators/generate-unique-items-check.js

@@ -0,0 +1,32 @@
+import { hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
+const SCALAR_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+const schemaIsScalarOnly = (schema) => {
+  if (schema === void 0 || !isSchemaObject(schema) || !hasType(schema))
+    return false;
+  const type = schema["type"];
+  const types = Array.isArray(type) ? type : [type];
+  return types.length > 0 && types.every((t) => typeof t === "string" && SCALAR_TYPES.has(t));
+};
+const arrayItemsAreScalarOnly = (schema) => {
+  if (!isSchemaObject(schema))
+    return false;
+  const record = schema;
+  const prefix = record["prefixItems"];
+  if (Array.isArray(prefix)) {
+    if (!prefix.every((position) => schemaIsScalarOnly(position)))
+      return false;
+    const tail = "items" in record ? record["items"] : record["additionalItems"];
+    return tail === false ? true : schemaIsScalarOnly(tail);
+  }
+  if (Array.isArray(record["items"])) {
+    if (!record["items"].every((position) => schemaIsScalarOnly(position)))
+      return false;
+    return record["additionalItems"] === false ? true : schemaIsScalarOnly(record["additionalItems"]);
+  }
+  return schemaIsScalarOnly(record["items"]);
+};
+const CANONICAL_JSON = 'JSON.stringify(_u, (_k, _v) => (_v !== null && typeof _v === "object" && !Array.isArray(_v)) ? Object.fromEntries(Object.keys(_v).sort().map((_sk) => [_sk, (_v as Record<string, unknown>)[_sk]])) : _v)';
+const generateUniqueItemsCheck = (accessor, schema) => arrayItemsAreScalarOnly(schema) ? `new Set(${accessor}).size === ${accessor}.length` : `new Set((${accessor} as unknown[]).map((_u) => ${CANONICAL_JSON})).size === ${accessor}.length`;
+export {
+  generateUniqueItemsCheck
+};

package/dist/generators/generate-validation-expression.d.ts

@@ -21,6 +21,22 @@ export declare const isCoercibleItemSchema: (itemSchema: JSONSchema) => boolean;
  * here rather than left unchecked.
  */
 export declare const getPrefixItems: (schema: JSONSchema) => readonly JSONSchema[] | null;
+/**
+ * Wraps a per-element boolean check into the `.every(...)` call that proves it
+ * for a whole array, skipping the positions `prefixItems` already owns.
+ *
+ * In 2020-12 `items` is only the *tail* schema: it applies from
+ * `prefixItems.length` onward. Checking every element against it made
+ * `{ prefixItems: [{type:'string'}], items: {type:'number'} }` reject
+ * `["a", 1, 2]` — a value Ajv accepts, and one the `[string?, ...number[]]` type
+ * this generator emits admits, so the strict parser threw on its own declared
+ * type. The index guard is short-circuited rather than sliced so the check stays
+ * allocation-free on the hot path.
+ *
+ * The draft-07 tuple spelling needs no guard: there `items` *is* the tuple and
+ * the tail lives in `additionalItems`, which no item check reads.
+ */
+export declare const everyTailItem: (accessor: string, itemCheck: string, schema: JSONSchema) => string;
 /**
  * True when a sibling `items: false` (2020-12) or `additionalItems: false`
  * (draft) caps a tuple's length — any element past the declared prefix is

package/dist/generators/generate-validation-expression.js

@@ -1,8 +1,8 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { safeAccessor } from "@amritk/helpers/safe-accessor";
+import { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { findDiscriminator } from "../helpers/find-discriminator.js";
 import { getDefaultValue } from "../helpers/get-default-value.js";
@@ -46,6 +46,11 @@ const getPrefixItems = (schema) => {
     return prefix;
   return Array.isArray(schema.items) ? schema.items : null;
 };
+const everyTailItem = (accessor, itemCheck, schema) => {
+  const prefix = isSchemaObject(schema) ? schema["prefixItems"] : void 0;
+  const tailStart = Array.isArray(prefix) ? prefix.length : 0;
+  return tailStart === 0 ? `${accessor}.every((_it) => ${itemCheck})` : `${accessor}.every((_it, _ix) => _ix < ${tailStart} || (${itemCheck}))`;
+};
 const prefixItemsCapsLength = (schema) => {
   if (!isSchemaObject(schema))
     return false;
@@ -206,7 +211,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
       case "string": {
         checks.push(`typeof ${accessor} === "string"`);
         if (hasPattern(schema)) {
-          checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+          checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
         }
         if (hasMinLength(schema)) {
           checks.push(`${accessor}.length >= ${schema.minLength}`);
@@ -262,7 +267,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
         checks.push(`isObject(${accessor})`);
         if (hasRequired(schema) && schema.required.length > 0) {
           for (const requiredKey of schema.required) {
-            checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+            checks.push(hasOwnCheck(accessor, requiredKey));
           }
         }
         if (hasMinProperties(schema)) {
@@ -325,6 +330,7 @@ const generatePrefixItemsMap = (accessor, prefix, capLength, rootSchema, visited
   return capLength ? `${mapped}.slice(0, ${prefix.length})` : mapped;
 };
 export {
+  everyTailItem,
   generatePrefixItemsMap,
   generateValidationExpression,
   getPrefixItems,

package/dist/generators/subschema-match.d.ts

@@ -1,4 +1,15 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * What the matcher needs beyond the schema node itself: the root document (to
+ * resolve `$ref`), the recursion depth (which seeds collision-free loop variable
+ * names and caps expression growth), and the `$ref` pointers already open on this
+ * path (a cycle cannot be inlined, so it bails rather than recursing forever).
+ */
+export type MatchContext = {
+    readonly rootSchema?: Record<string, unknown>;
+    readonly depth?: number;
+    readonly seen?: ReadonlySet<string>;
+};
 /**
  * Builds a boolean expression that is `true` *exactly* when `accessor` matches
  * `schema` — sound in **both** directions (true ⇒ valid, false ⇒ invalid) — or
@@ -17,13 +28,21 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * types), so a type-less schema guards each family by its runtime type rather
  * than ignoring it — the subtlety `propertyNames: { maxLength: 3 }` depends on.
  *
- * `depth` seeds the `.every` element variable so nested array matches never
- * shadow one another.
+ * `ctx.depth` seeds the loop variable names so nested walks never shadow one
+ * another, and caps how far the expression may grow.
+ */
+export declare const subschemaMatchExpr: (accessor: string, schema: JSONSchema, ctx?: MatchContext) => string | null;
+/**
+ * True when a `$ref` node carries a keyword that constrains the value on its own.
+ * 2020-12 applies a `$ref`'s siblings alongside the target, so delegating the
+ * whole node to the referenced parser (which knows nothing about them) drops
+ * every one of them — and a fast path built from the target's shape validator
+ * skips them too.
  */
-export declare const subschemaMatchExpr: (accessor: string, schema: JSONSchema, depth?: number) => string | null;
+export declare const hasConstrainingRefSibling: (schema: JSONSchema) => boolean;
 /**
  * Whether {@link subschemaMatchExpr} can build an exact matcher for `schema`.
  * The generation-time guard uses this to decide whether a `contains`,
  * `propertyNames`, or `dependentSchemas` subschema is enforceable.
  */
-export declare const canMatchSubschema: (schema: JSONSchema) => boolean;
+export declare const canMatchSubschema: (schema: JSONSchema, rootSchema?: Record<string, unknown>) => boolean;