@amritk/generate-parsers 0.16.0 → 0.16.1

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

@@ -16,9 +16,14 @@ import { generateSchemaChecks } from './generate-schema-checks.js';
  * epoch number); other classes have no safe generic coercion, so we return null
  * and the caller falls back to the default.
  */
-const getInstanceCoercion = (accessor, instanceOf) => {
+const getInstanceCoercion = (accessor, instanceOf, defaultValue) => {
+    // A bare `new Date(bad)` yields an `Invalid Date` — an object that is
+    // `instanceof Date` yet whose every operation is `NaN`, silently poisoning
+    // downstream code. Construct once, then fall back to the default when the
+    // result is invalid. This sits on the coercion (failure) branch only, so the
+    // hot path never pays for it.
     if (instanceOf === 'Date')
-        return `new Date(${accessor} as string | number | Date)`;
+        return `((_d) => Number.isNaN(_d.getTime()) ? ${defaultValue} : _d)(new Date(${accessor} as string | number | Date))`;
     return null;
 };
 /**
@@ -57,6 +62,29 @@ export const isCoercibleItemSchema = (itemSchema) => {
         return true;
     return isSchemaObject(itemSchema) && hasEnum(itemSchema) && itemSchema.enum.length > 0;
 };
+/**
+ * The tuple `prefixItems` array when the schema declares one, else `null`.
+ * `prefixItems` (JSON Schema 2020-12) positions each element against its own
+ * subschema; the draft array-form `items` is handled by the existing item
+ * paths, not here.
+ */
+export const getPrefixItems = (schema) => {
+    if (!isSchemaObject(schema))
+        return null;
+    const prefix = schema['prefixItems'];
+    return Array.isArray(prefix) ? prefix : null;
+};
+/**
+ * True when a sibling `items: false` (2020-12) or `additionalItems: false`
+ * (draft) caps a tuple's length — any element past the declared prefix is
+ * disallowed, so the coercer drops it and strict mode rejects it.
+ */
+export const prefixItemsCapsLength = (schema) => {
+    if (!isSchemaObject(schema))
+        return false;
+    const s = schema;
+    return s['items'] === false || s['additionalItems'] === false;
+};
 /**
  * A boolean type check for a single JSON Schema primitive type name. Unlike
  * {@link scalarItemTypeCheck} this also covers `array`/`object` (as inline shape
@@ -140,12 +168,15 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
     const instanceOf = getMjstInstanceOf(schema);
     if (instanceOf) {
         const valid = `${accessor} instanceof ${instanceOf}`;
-        const coercion = getInstanceCoercion(accessor, instanceOf);
+        // The coercer's own invalid-value fallback matches the branch it sits on:
+        // the default for a required property, `undefined` for an optional one.
         if (isRequired) {
+            const coercion = getInstanceCoercion(accessor, instanceOf, defaultValue);
             return coercion
                 ? `${valid} ? ${accessor} : (${accessor} !== undefined ? ${coercion} : ${defaultValue})`
                 : `${valid} ? ${accessor} : ${defaultValue}`;
         }
+        const coercion = getInstanceCoercion(accessor, instanceOf, 'undefined');
         return coercion
             ? `${valid} ? ${accessor} : (${accessor} !== undefined ? ${coercion} : undefined)`
             : `${valid} ? ${accessor} : undefined`;
@@ -239,6 +270,17 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
     if (!hasType(schema) && !hasEnum(schema)) {
         return `${accessor} ?? ${defaultValue}`;
     }
+    // Tuple `prefixItems`: coerce each declared position through its own subschema
+    // and, with a sibling `items: false`/`additionalItems: false`, drop any element
+    // past the tuple length. A shorter input keeps its absent trailing positions.
+    // The fast path only takes a tuple whose present positions are already
+    // well-typed, so a mistyped position reaches here.
+    const prefixItems = getPrefixItems(schema);
+    if (hasType(schema) && schema.type === 'array' && prefixItems) {
+        const mapped = generatePrefixItemsMap(accessor, prefixItems, prefixItemsCapsLength(schema), rootSchema, visitedRefs, caseInsensitive);
+        const built = `(Array.isArray(${accessor}) ? ${mapped} : ${defaultValue})`;
+        return isRequired ? built : `(${accessor} !== undefined ? ${built} : undefined)`;
+    }
     // An array of scalar or enum items: coerce each element so e.g. `number[]`
     // actually contains numbers and an enum member set holds. The fast path only
     // takes a well-typed array, so a mistyped element reaches here. ($ref and
@@ -393,3 +435,30 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
         return `${combinedCheck} ? ${accessor} : ${enumFallback('undefined')}`;
     }
 };
+/**
+ * Builds the coercion transform for a tuple `prefixItems` array: an index-matched
+ * `.map` where each declared position runs through its own subschema's coercion
+ * (present positions only — a shorter input keeps its absent trailing positions),
+ * and every element past the tuple passes through unchanged. When `capLength` is
+ * set (a sibling `items: false`), a trailing `.slice(0, N)` drops those extras.
+ * `accessor` must already be known to be an array (the caller guards with
+ * `Array.isArray`). `$ref` positions resolve against `rootSchema` when provided.
+ */
+export const generatePrefixItemsMap = (accessor, prefix, capLength, rootSchema, visitedRefs, caseInsensitive) => {
+    const branches = prefix.map((rawPos, i) => {
+        // Resolve a position `$ref` to its target here: generateValidationExpression's
+        // own ref path rebuilds the accessor from the property key, which would
+        // discard the `_el` element accessor an override needs — so hand it the
+        // concrete schema directly instead.
+        let pos = rawPos;
+        if (isSchemaObject(pos) && hasRef(pos) && rootSchema) {
+            const resolved = resolveRef(pos.$ref, rootSchema);
+            if (resolved)
+                pos = resolved;
+        }
+        const posExpr = generateValidationExpression('', pos, getDefaultValue(pos), true, rootSchema, visitedRefs, '_el', true, caseInsensitive);
+        return `_i === ${i} ? ${posExpr}`;
+    });
+    const mapped = `(${accessor} as unknown[]).map((_el, _i) => ${[...branches, '_el'].join(' : ')})`;
+    return capLength ? `${mapped}.slice(0, ${prefix.length})` : mapped;
+};

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

@@ -0,0 +1,29 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Builds a boolean expression that is `true` *exactly* when `accessor` matches
+ * `schema` — sound in **both** directions (true ⇒ valid, false ⇒ invalid) — or
+ * `null` when the schema uses a form this generator cannot prove inline.
+ *
+ * This is deliberately self-contained: it never emits a `$ref` shape-validator
+ * call (those can be conservative `=> false` stubs, which would break false-
+ * soundness) and never touches combinators. That keeps the expression usable
+ * both for *counting* matches (`contains`) and for *rejecting* non-matches
+ * (`propertyNames`, `dependentSchemas`) in strict mode, where a wrong verdict
+ * would silently accept or reject a document. Anything richer returns `null`,
+ * and `assertNoUnsupportedKeywords` turns that into a generation-time error.
+ *
+ * Constraint keywords apply per JSON Schema semantics: a `pattern`/`maxLength`
+ * with no `type` still constrains string instances (and is a no-op for other
+ * 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.
+ */
+export declare const subschemaMatchExpr: (accessor: string, schema: JSONSchema, depth?: number) => string | null;
+/**
+ * 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;

package/dist/generators/subschema-match.js

@@ -0,0 +1,286 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
+import { multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
+import { safeAccessor } from '@amritk/helpers/safe-accessor';
+import { hasAdditionalProperties, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { generateEnumCheck } from './generate-enum-check.js';
+/**
+ * Keywords `subschemaMatchExpr` reads and enforces. A subschema carrying any
+ * keyword outside this set (and the annotation set below) cannot be matched
+ * *exactly*, so the matcher bails to `null` and the generation-time guard turns
+ * that into a hard error rather than a permissive parser.
+ */
+const HANDLED_KEYWORDS = new Set([
+    'type',
+    'enum',
+    'const',
+    'pattern',
+    'minLength',
+    'maxLength',
+    'minimum',
+    'maximum',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+    'multipleOf',
+    'minItems',
+    'maxItems',
+    'uniqueItems',
+    'items',
+    'required',
+    'properties',
+    'minProperties',
+    'maxProperties',
+    'additionalProperties',
+]);
+/**
+ * Keywords that only annotate (Ajv, our differential oracle, does not assert on
+ * them under `strict: false`), so their presence never blocks an exact match.
+ * `format` is annotation-only in 2020-12 by default, matching the oracle.
+ */
+const ANNOTATION_KEYWORDS = new Set([
+    'title',
+    'description',
+    '$comment',
+    '$id',
+    '$schema',
+    '$anchor',
+    '$vocabulary',
+    '$defs',
+    'definitions',
+    'examples',
+    'default',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+    'format',
+    'contentMediaType',
+    'contentEncoding',
+    'contentSchema',
+]);
+const isObjectExpr = (acc) => `typeof ${acc} === "object" && ${acc} !== null && !Array.isArray(${acc})`;
+/** True when `additionalProperties` is a constraining (non-boolean) schema. */
+const hasSchemaAdditionalProperties = (schema) => hasAdditionalProperties(schema) &&
+    typeof schema.additionalProperties !== 'boolean';
+/**
+ * String-family constraint checks (no type assertion). Every JSON Schema string
+ * keyword only asserts on string instances, so these are combined with a
+ * `typeof === "string"` — either as the assertion (a `type: 'string'` schema) or
+ * as a guard (`typeof !== "string" || …` for a type-less schema).
+ */
+const stringConstraints = (acc, schema) => {
+    const c = [];
+    if (hasPattern(schema))
+        c.push(`/${escapeRegexPattern(schema.pattern)}/.test(${acc})`);
+    if (hasMinLength(schema))
+        c.push(`${acc}.length >= ${schema.minLength}`);
+    if (hasMaxLength(schema))
+        c.push(`${acc}.length <= ${schema.maxLength}`);
+    return c;
+};
+/** Number-family constraint checks (no type assertion). `integer` requires an explicit type. */
+const numberConstraints = (acc, schema, integer) => {
+    const c = [];
+    if (integer)
+        c.push(`Number.isInteger(${acc})`);
+    if (hasMinimum(schema))
+        c.push(`${acc} >= ${schema.minimum}`);
+    if (hasMaximum(schema))
+        c.push(`${acc} <= ${schema.maximum}`);
+    if (hasExclusiveMinimum(schema))
+        c.push(`${acc} > ${schema.exclusiveMinimum}`);
+    if (hasExclusiveMaximum(schema))
+        c.push(`${acc} < ${schema.exclusiveMaximum}`);
+    if (hasMultipleOf(schema))
+        c.push(multipleOfPassExpr(acc, schema.multipleOf));
+    return c;
+};
+/** Array-family constraint checks (no `Array.isArray` assertion). `null` when an item schema is unprovable. */
+const arrayConstraints = (acc, schema, depth) => {
+    const c = [];
+    if (hasMinItems(schema))
+        c.push(`${acc}.length >= ${schema.minItems}`);
+    if (hasMaxItems(schema))
+        c.push(`${acc}.length <= ${schema.maxItems}`);
+    if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+        c.push(`new Set((${acc} as unknown[]).map((_u) => JSON.stringify(_u))).size === ${acc}.length`);
+    }
+    if (hasItems(schema)) {
+        if (Array.isArray(schema.items))
+            return null;
+        const el = `_i${depth}`;
+        const itemMatch = subschemaMatchExpr(el, schema.items, depth + 1);
+        if (itemMatch === null)
+            return null;
+        if (itemMatch !== 'true')
+            c.push(`(${acc} as unknown[]).every((${el}) => ${itemMatch})`);
+    }
+    return c;
+};
+/** Object-family constraint checks (no object-type assertion). `null` when a property schema is unprovable. */
+const objectConstraints = (acc, schema, depth) => {
+    // A schema-valued additionalProperties record would leave record values unproven.
+    if (hasSchemaAdditionalProperties(schema))
+        return null;
+    const c = [];
+    const required = new Set(hasRequired(schema) ? schema.required : []);
+    if (hasProperties(schema)) {
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            const propAcc = safeAccessor(acc, key);
+            const propMatch = subschemaMatchExpr(propAcc, propSchema, depth + 1);
+            if (propMatch === null)
+                return null;
+            if (required.has(key)) {
+                c.push(propMatch === 'true'
+                    ? `${JSON.stringify(key)} in ${acc}`
+                    : `(${JSON.stringify(key)} in ${acc} && ${propMatch})`);
+            }
+            else if (propMatch !== 'true') {
+                c.push(`(${propAcc} === undefined || ${propMatch})`);
+            }
+            required.delete(key);
+        }
+    }
+    for (const key of required)
+        c.push(`${JSON.stringify(key)} in ${acc}`);
+    if (hasMinProperties(schema))
+        c.push(`Object.keys(${acc}).length >= ${schema.minProperties}`);
+    if (hasMaxProperties(schema))
+        c.push(`Object.keys(${acc}).length <= ${schema.maxProperties}`);
+    if (hasAdditionalProperties(schema) && schema.additionalProperties === false) {
+        const allowed = JSON.stringify(hasProperties(schema) ? Object.keys(schema.properties) : []);
+        c.push(`Object.keys(${acc}).every((_k) => ${allowed}.includes(_k))`);
+    }
+    return c;
+};
+/**
+ * Builds a boolean expression that is `true` *exactly* when `accessor` matches
+ * `schema` — sound in **both** directions (true ⇒ valid, false ⇒ invalid) — or
+ * `null` when the schema uses a form this generator cannot prove inline.
+ *
+ * This is deliberately self-contained: it never emits a `$ref` shape-validator
+ * call (those can be conservative `=> false` stubs, which would break false-
+ * soundness) and never touches combinators. That keeps the expression usable
+ * both for *counting* matches (`contains`) and for *rejecting* non-matches
+ * (`propertyNames`, `dependentSchemas`) in strict mode, where a wrong verdict
+ * would silently accept or reject a document. Anything richer returns `null`,
+ * and `assertNoUnsupportedKeywords` turns that into a generation-time error.
+ *
+ * Constraint keywords apply per JSON Schema semantics: a `pattern`/`maxLength`
+ * with no `type` still constrains string instances (and is a no-op for other
+ * 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.
+ */
+export const subschemaMatchExpr = (accessor, schema, depth = 0) => {
+    // Boolean schemas: `true` matches everything, `false` matches nothing.
+    if (schema === true)
+        return 'true';
+    if (schema === false)
+        return 'false';
+    if (!isSchemaObject(schema))
+        return null;
+    // Any keyword we neither handle nor know to be a pure annotation could narrow
+    // the value set; matching would then be unsound, so bail.
+    for (const key of Object.keys(schema)) {
+        if (!HANDLED_KEYWORDS.has(key) && !ANNOTATION_KEYWORDS.has(key))
+            return null;
+    }
+    // An array-form `type` (multi-type / nullable) is a disjunction we do not
+    // prove inline here; `hasType` is false for it, so without this it would fall
+    // through to a permissive result.
+    if ('type' in schema && typeof schema.type !== 'string')
+        return null;
+    const checks = [];
+    // `const` — a single exact value. Primitives compare with `===`; a structural
+    // const would need deep equality, which this flat matcher does not attempt.
+    if (hasConst(schema)) {
+        const c = schema.const;
+        if (c !== null && typeof c === 'object')
+            return null;
+        checks.push(`${accessor} === ${JSON.stringify(c)}`);
+    }
+    // `enum` — membership in a fixed set (generateEnumCheck is exact).
+    if (hasEnum(schema)) {
+        if (schema.enum.length === 0)
+            return null;
+        checks.push(generateEnumCheck(accessor, schema.enum));
+    }
+    if (hasType(schema)) {
+        const typeChecks = buildTypedChecks(accessor, schema, depth);
+        if (typeChecks === null)
+            return null;
+        checks.push(...typeChecks);
+    }
+    else {
+        const typeless = buildTypelessChecks(accessor, schema, depth);
+        if (typeless === null)
+            return null;
+        checks.push(...typeless);
+    }
+    // A schema with no proven constraint matches every value.
+    if (checks.length === 0)
+        return 'true';
+    return checks.length === 1 ? checks[0] : `(${checks.join(' && ')})`;
+};
+/** Type assertion plus that type's constraints, for a single-`type` schema. */
+const buildTypedChecks = (accessor, schema, depth) => {
+    switch (schema.type) {
+        case 'string':
+            return [`typeof ${accessor} === "string"`, ...stringConstraints(accessor, schema)];
+        case 'number':
+            return [`typeof ${accessor} === "number"`, ...numberConstraints(accessor, schema, false)];
+        case 'integer':
+            return [`typeof ${accessor} === "number"`, ...numberConstraints(accessor, schema, true)];
+        case 'boolean':
+            return [`typeof ${accessor} === "boolean"`];
+        case 'null':
+            return [`${accessor} === null`];
+        case 'array': {
+            const constraints = arrayConstraints(accessor, schema, depth);
+            if (constraints === null)
+                return null;
+            return [`Array.isArray(${accessor})`, ...constraints];
+        }
+        case 'object': {
+            const constraints = objectConstraints(accessor, schema, depth);
+            if (constraints === null)
+                return null;
+            return [isObjectExpr(accessor), ...constraints];
+        }
+        default:
+            return null;
+    }
+};
+/**
+ * Constraints on a schema with no `type`: each family only asserts on instances
+ * of its type, so guard each present family by its runtime type. A value of a
+ * different type satisfies the family vacuously.
+ */
+const buildTypelessChecks = (accessor, schema, depth) => {
+    const checks = [];
+    const strChecks = stringConstraints(accessor, schema);
+    if (strChecks.length > 0)
+        checks.push(`(typeof ${accessor} !== "string" || ${joinAnd(strChecks)})`);
+    const numChecks = numberConstraints(accessor, schema, false);
+    if (numChecks.length > 0)
+        checks.push(`(typeof ${accessor} !== "number" || ${joinAnd(numChecks)})`);
+    const arrChecks = arrayConstraints(accessor, schema, depth);
+    if (arrChecks === null)
+        return null;
+    if (arrChecks.length > 0)
+        checks.push(`(!Array.isArray(${accessor}) || ${joinAnd(arrChecks)})`);
+    const objChecks = objectConstraints(accessor, schema, depth);
+    if (objChecks === null)
+        return null;
+    if (objChecks.length > 0)
+        checks.push(`(!(${isObjectExpr(accessor)}) || ${joinAnd(objChecks)})`);
+    return checks;
+};
+const joinAnd = (checks) => (checks.length === 1 ? checks[0] : `(${checks.join(' && ')})`);
+/**
+ * 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 const canMatchSubschema = (schema) => subschemaMatchExpr('_x', schema) !== null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.12.0",
+    "@amritk/helpers": "0.13.0",
     "@amritk/generate-markdown": "0.4.1"
   },
   "devDependencies": {