@amritk/generate-parsers 0.12.3 → 0.14.0

package/dist/generators/generate-strict-assertion.d.ts

@@ -1,4 +1,19 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Context for assertions that reach beyond the property's own schema: union
+ * membership checks may call imported `validate{X}Shape` predicates ($ref
+ * branches), which requires knowing the ref-import mode, the type-name suffix,
+ * and the root document (to prove those validators are real — see
+ * canEnforceUnion). `stripUnknown` disables union enforcement entirely, since
+ * shape validators then treat undeclared keys as a mismatch while the
+ * stripUnknown contract is to drop them.
+ */
+export type StrictAssertionContext = {
+    readonly useRefImports?: boolean;
+    readonly suffix?: string;
+    readonly rootSchema?: Record<string, unknown>;
+    readonly stripUnknown?: boolean;
+};
 /**
  * Generates strict-mode assertions for the body of an object parser.
  * Throws on:
@@ -10,7 +25,7 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Properties with a `$ref` are validated by the nested parser's own strict
  * check when that parser is invoked downstream.
  */
-export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeName: string) => string[];
+export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeName: string, context?: StrictAssertionContext) => string[];
 /**
  * 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.

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

@@ -1,8 +1,12 @@
 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 { quoteJsString } from '@amritk/helpers/quote-js-string';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
-import { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, 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.
@@ -18,6 +22,11 @@ const wrongTypeCondition = (accessor, type) => {
             return `(typeof ${accessor} !== "number" || !Number.isInteger(${accessor}))`;
         case 'boolean':
             return `typeof ${accessor} !== "boolean"`;
+        case 'null':
+            // Missing from this switch historically, which meant a null-typed
+            // property was never enforced on the assertion path — the strict-mode
+            // differential fuzzer caught non-null values sailing through.
+            return `${accessor} !== null`;
         case 'array':
             return `!Array.isArray(${accessor})`;
         case 'object':
@@ -33,14 +42,13 @@ const wrongTypeCondition = (accessor, type) => {
 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`).
+ * contain schema-controlled text (property names, patterns, enum values), so
+ * it goes through the shared {@link quoteJsString} escape-or-quote decision.
+ * `suffixExpr`, when given, is a runtime expression appended to the message
+ * (e.g. `typeof input`).
  */
 const throwError = (message, suffixExpr) => {
-    const literal = JSON.stringify(message);
+    const literal = quoteJsString(message);
     return suffixExpr ? `throw new Error(${literal} + (${suffixExpr}))` : `throw new Error(${literal})`;
 };
 /**
@@ -94,15 +102,41 @@ const generateConstraintChecks = (acc, propSchema, typeName, key) => {
             // 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 = [];
@@ -113,6 +147,21 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
         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) {
@@ -171,14 +220,15 @@ 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)) ${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));
+    const props = schema.properties;
+    for (const key in props) {
+        lines.push(...generatePropertyAssertion(key, props[key], required.has(key), typeName, context));
     }
     return lines;
 };
@@ -202,5 +252,14 @@ export const generateScalarStrictAssertion = (schema, typeName) => {
     const wrongType = wrongTypeCondition('input', t);
     if (!wrongType)
         return null;
-    return `  if (${wrongType}) ${throwError(`[${typeName}] expected ${typeLabel(t)}, got `, got)};`;
+    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,82 @@
+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;
+/**
+ * Matches an inline nested object property — an object schema written directly
+ * under `properties` with its own `properties`, rather than referenced via
+ * `$ref`. These get a private sub-parser (and shape predicate) in the same
+ * generated file so their fields are actually parsed; anything involving
+ * composition, conditionals, enums, or record semantics keeps the existing
+ * code paths.
+ */
+export declare const isInlineObjectProperty: (propSchema: JSONSchema) => propSchema is JSONSchema.Object;
+/**
+ * Matches an array property whose `items` is an inline object schema — the
+ * array-items analogue of {@link isInlineObjectProperty}. These get a private
+ * item sub-parser (and shape predicate) so element values — including nested
+ * enums and `$ref`s — are actually validated instead of only passing an
+ * `Array.isArray` check.
+ */
+export declare const isInlineObjectArrayProperty: (propSchema: JSONSchema) => boolean;
+/**
+ * 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;