@amritk/generate-parsers 0.16.2 → 0.17.0

package/dist/generators/subschema-match.js

@@ -1,286 +1,221 @@
-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',
+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";
+const HANDLED_KEYWORDS = /* @__PURE__ */ 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 ANNOTATION_KEYWORDS = /* @__PURE__ */ 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 hasSchemaAdditionalProperties = (schema) => hasAdditionalProperties(schema) && typeof schema.additionalProperties !== "boolean";
 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;
+  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;
+  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;
+  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))
+  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;
-    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);
-        }
+      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;
+  }
+  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;
+};
+const subschemaMatchExpr = (accessor, schema, depth = 0) => {
+  if (schema === true)
+    return "true";
+  if (schema === false)
+    return "false";
+  if (!isSchemaObject(schema))
+    return null;
+  for (const key of Object.keys(schema)) {
+    if (!HANDLED_KEYWORDS.has(key) && !ANNOTATION_KEYWORDS.has(key))
+      return null;
+  }
+  if ("type" in schema && typeof schema.type !== "string")
+    return null;
+  const checks = [];
+  if (hasConst(schema)) {
+    const c = schema.const;
+    if (c !== null && typeof c === "object")
+      return null;
+    checks.push(`${accessor} === ${JSON.stringify(c)}`);
+  }
+  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);
+  }
+  if (checks.length === 0)
+    return "true";
+  return checks.length === 1 ? checks[0] : `(${checks.join(" && ")})`;
 };
-/**
- * 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))
+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;
-    // 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;
+      return [`Array.isArray(${accessor})`, ...constraints];
     }
-    // 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')
+    case "object": {
+      const constraints = objectConstraints(accessor, schema, depth);
+      if (constraints === null)
         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;
+      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 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(" && ")})`;
+const canMatchSubschema = (schema) => subschemaMatchExpr("_x", schema) !== null;
+export {
+  canMatchSubschema,
+  subschemaMatchExpr
 };
-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/dist/helpers/apply-schema-extensions.js

@@ -1,51 +1,20 @@
-/**
- * Merges custom extension properties into a schema's properties based on the
- * definition name. Extension properties are added as optional (not included
- * in the required array) since they are custom additions that may not always
- * be present.
- *
- * If the schema is not an object, has no matching extensions, or the
- * extensions record is empty, the original schema is returned unchanged.
- *
- * @param schema - The JSON Schema to extend
- * @param definitionName - The name of the definition (e.g., "parameter")
- * @param extensions - The extensions configuration mapping definition names to properties
- * @returns A new schema with extension properties merged in, or the original if unchanged
- *
- * @example
- * ```typescript
- * const schema = {
- *   type: 'object',
- *   properties: { name: { type: 'string' } },
- *   required: ['name'],
- * }
- *
- * const extensions = {
- *   parameter: {
- *     'x-enabled': { type: 'boolean' },
- *   },
- * }
- *
- * const extended = applySchemaExtensions(schema, 'parameter', extensions)
- * // extended.properties now includes 'x-enabled' alongside 'name'
- * ```
- */
-export const applySchemaExtensions = (schema, definitionName, extensions) => {
-    const extensionProperties = extensions[definitionName];
-    if (!extensionProperties || Object.keys(extensionProperties).length === 0) {
-        return schema;
+const applySchemaExtensions = (schema, definitionName, extensions) => {
+  const extensionProperties = extensions[definitionName];
+  if (!extensionProperties || Object.keys(extensionProperties).length === 0) {
+    return schema;
+  }
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  const existingProperties = "properties" in schema && typeof schema.properties === "object" && schema.properties !== null ? schema.properties : {};
+  return {
+    ...schema,
+    properties: {
+      ...existingProperties,
+      ...extensionProperties
     }
-    if (typeof schema !== 'object' || schema === null) {
-        return schema;
-    }
-    const existingProperties = 'properties' in schema && typeof schema.properties === 'object' && schema.properties !== null
-        ? schema.properties
-        : {};
-    return {
-        ...schema,
-        properties: {
-            ...existingProperties,
-            ...extensionProperties,
-        },
-    };
+  };
+};
+export {
+  applySchemaExtensions
 };