@amritk/generate-parsers 0.18.0 → 0.19.0

package/dist/generators/subschema-match.js

@@ -1,8 +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 { 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 { resolveRef } from "@amritk/helpers/resolve-ref";
+import { hasOwnCheck, missingCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
+import { 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 { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
+import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
 import { generateEnumCheck } from "./generate-enum-check.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
+import { unevaluatedItemsExpr, unevaluatedPropertiesExpr } from "./unevaluated-match.js";
 const HANDLED_KEYWORDS = /* @__PURE__ */ new Set([
   "type",
   "enum",
@@ -19,11 +24,30 @@ const HANDLED_KEYWORDS = /* @__PURE__ */ new Set([
   "maxItems",
   "uniqueItems",
   "items",
+  "prefixItems",
+  "additionalItems",
+  "contains",
+  "minContains",
+  "maxContains",
   "required",
   "properties",
+  "patternProperties",
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas",
   "minProperties",
   "maxProperties",
-  "additionalProperties"
+  "additionalProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "$ref",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "not",
+  "if",
+  "then",
+  "else"
 ]);
 const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
   "title",
@@ -32,6 +56,7 @@ const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
   "$id",
   "$schema",
   "$anchor",
+  "$dynamicAnchor",
   "$vocabulary",
   "$defs",
   "definitions",
@@ -45,16 +70,24 @@ const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
   "contentEncoding",
   "contentSchema"
 ]);
+const depthOf = (ctx) => ctx.depth ?? 0;
+const nest = (ctx) => ({ ...ctx, depth: depthOf(ctx) + 1 });
 const isObjectExpr = (acc) => `typeof ${acc} === "object" && ${acc} !== null && !Array.isArray(${acc})`;
-const hasSchemaAdditionalProperties = (schema) => hasAdditionalProperties(schema) && typeof schema.additionalProperties !== "boolean";
+const recordOf = (acc) => `(${acc} as Record<string, unknown>)`;
+const patternEntriesOf = (schema) => {
+  const source = schema["patternProperties"];
+  if (typeof source !== "object" || source === null || Array.isArray(source))
+    return null;
+  return Object.entries(source);
+};
 const stringConstraints = (acc, schema) => {
   const c = [];
   if (hasPattern(schema))
-    c.push(`/${escapeRegexPattern(schema.pattern)}/.test(${acc})`);
+    c.push(`${regexLiteral(schema.pattern)}.test(${acc})`);
   if (hasMinLength(schema))
-    c.push(`${acc}.length >= ${schema.minLength}`);
+    c.push(minLengthPassExpr(acc, schema.minLength));
   if (hasMaxLength(schema))
-    c.push(`${acc}.length <= ${schema.maxLength}`);
+    c.push(maxLengthPassExpr(acc, schema.maxLength));
   return c;
 };
 const numberConstraints = (acc, schema, integer) => {
@@ -73,40 +106,103 @@ const numberConstraints = (acc, schema, integer) => {
     c.push(multipleOfPassExpr(acc, schema.multipleOf));
   return c;
 };
-const arrayConstraints = (acc, schema, depth) => {
+const tupleShape = (schema) => {
+  const s = schema;
+  const declared = s["prefixItems"];
+  if (Array.isArray(declared))
+    return { prefix: declared, tail: s["items"] };
+  if (Array.isArray(s["items"]))
+    return { prefix: s["items"], tail: s["additionalItems"] };
+  return { prefix: null, tail: void 0 };
+};
+const arrayConstraints = (acc, schema, ctx) => {
   const c = [];
+  const d = depthOf(ctx);
+  const elements = `(${acc} as unknown[])`;
   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`);
+    c.push(generateUniqueItemsCheck(acc, schema));
   }
-  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})`);
+  const { prefix, tail } = tupleShape(schema);
+  if (prefix) {
+    for (let i = 0; i < prefix.length; i++) {
+      const positional = subschemaMatchExpr(`${elements}[${i}]`, prefix[i], nest(ctx));
+      if (positional === null)
+        return null;
+      if (positional === "true")
+        continue;
+      c.push(`(${acc}.length <= ${i} || ${positional})`);
+    }
+    if (tail === false) {
+      c.push(`${acc}.length <= ${prefix.length}`);
+    } else if (tail !== void 0 && tail !== true) {
+      const el = `_i${d}`;
+      const tailMatch = subschemaMatchExpr(el, tail, nest(ctx));
+      if (tailMatch === null)
+        return null;
+      if (tailMatch !== "true")
+        c.push(`${elements}.every((${el}, _x${d}) => _x${d} < ${prefix.length} || ${tailMatch})`);
+    }
+  } else if ("items" in schema) {
+    if (schema["items"] === false) {
+      c.push(`${acc}.length === 0`);
+    } else if (hasItems(schema)) {
+      const el = `_i${d}`;
+      const itemMatch = subschemaMatchExpr(el, schema.items, nest(ctx));
+      if (itemMatch === null)
+        return null;
+      if (itemMatch !== "true")
+        c.push(`${elements}.every((${el}) => ${itemMatch})`);
+    }
   }
+  const contains = containsConstraint(acc, schema, ctx);
+  if (contains === null)
+    return null;
+  c.push(...contains);
+  const unevaluated = unevaluatedItemsExpr(acc, schema, ctx, subschemaMatchExpr);
+  if (unevaluated === null)
+    return null;
+  if (unevaluated !== void 0)
+    c.push(unevaluated);
   return c;
 };
-const objectConstraints = (acc, schema, depth) => {
-  if (hasSchemaAdditionalProperties(schema))
+const containsConstraint = (acc, schema, ctx) => {
+  const s = schema;
+  if (!("contains" in s))
+    return [];
+  const d = depthOf(ctx);
+  const min = typeof s["minContains"] === "number" ? s["minContains"] : 1;
+  const max = typeof s["maxContains"] === "number" ? s["maxContains"] : void 0;
+  if (min === 0 && max === void 0)
+    return [];
+  const el = `_c${d}`;
+  const match = subschemaMatchExpr(el, s["contains"], nest(ctx));
+  if (match === null)
     return null;
+  const count = `(${acc} as unknown[]).filter((${el}) => ${match}).length`;
+  const bounds = [];
+  if (min > 0)
+    bounds.push(`${count} >= ${min}`);
+  if (max !== void 0)
+    bounds.push(`${count} <= ${max}`);
+  return bounds;
+};
+const objectConstraints = (acc, schema, ctx) => {
   const c = [];
+  const d = depthOf(ctx);
   const required = new Set(hasRequired(schema) ? schema.required : []);
+  const rec = recordOf(acc);
   if (hasProperties(schema)) {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
-      const propAcc = safeAccessor(acc, key);
-      const propMatch = subschemaMatchExpr(propAcc, propSchema, depth + 1);
+      const propAcc = safeAccessor(rec, key);
+      const propMatch = subschemaMatchExpr(propAcc, propSchema, nest(ctx));
       if (propMatch === null)
         return null;
       if (required.has(key)) {
-        c.push(propMatch === "true" ? `${JSON.stringify(key)} in ${acc}` : `(${JSON.stringify(key)} in ${acc} && ${propMatch})`);
+        c.push(propMatch === "true" ? hasOwnCheck(rec, key) : `(${hasOwnCheck(rec, key)} && ${propMatch})`);
       } else if (propMatch !== "true") {
         c.push(`(${propAcc} === undefined || ${propMatch})`);
       }
@@ -114,18 +210,100 @@ const objectConstraints = (acc, schema, depth) => {
     }
   }
   for (const key of required)
-    c.push(`${JSON.stringify(key)} in ${acc}`);
+    c.push(hasOwnCheck(rec, key));
   if (hasMinProperties(schema))
-    c.push(`Object.keys(${acc}).length >= ${schema.minProperties}`);
+    c.push(`Object.keys(${rec}).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))`);
+    c.push(`Object.keys(${rec}).length <= ${schema.maxProperties}`);
+  const keyTerms = keyWalkTerms(`_k${d}`, `_v${d}`, schema, ctx);
+  if (keyTerms === null)
+    return null;
+  if (keyTerms.length > 0) {
+    const needsValue = keyTerms.some((term) => term.usesValue);
+    const body = keyTerms.map((term) => term.expr).join(" && ");
+    c.push(needsValue ? `Object.keys(${rec}).every((_k${d}) => { const _v${d} = ${rec}[_k${d}]; return ${body}; })` : `Object.keys(${rec}).every((_k${d}) => ${body})`);
   }
+  const dependent = dependentTerms(rec, acc, schema, ctx);
+  if (dependent === null)
+    return null;
+  c.push(...dependent);
+  const unevaluated = unevaluatedPropertiesExpr(acc, schema, ctx, subschemaMatchExpr);
+  if (unevaluated === null)
+    return null;
+  if (unevaluated !== void 0)
+    c.push(unevaluated);
   return c;
 };
-const subschemaMatchExpr = (accessor, schema, depth = 0) => {
+const keyWalkTerms = (keyVar, valueVar, schema, ctx) => {
+  const terms = [];
+  const patterns = patternEntriesOf(schema);
+  const declared = hasProperties(schema) ? Object.keys(schema.properties) : [];
+  if (patterns) {
+    for (const [pattern, sub] of patterns) {
+      const match = subschemaMatchExpr(valueVar, sub, nest(ctx));
+      if (match === null)
+        return null;
+      if (match === "true")
+        continue;
+      terms.push({ expr: `(!${regexLiteral(pattern)}.test(${keyVar}) || ${match})`, usesValue: true });
+    }
+  }
+  const additional = schema["additionalProperties"];
+  if (additional !== void 0 && additional !== true) {
+    const guards = [];
+    if (declared.length > 0)
+      guards.push(`!${JSON.stringify(declared)}.includes(${keyVar})`);
+    if (patterns)
+      for (const [pattern] of patterns)
+        guards.push(`!${regexLiteral(pattern)}.test(${keyVar})`);
+    const unclaimed = guards.length > 0 ? guards.join(" && ") : null;
+    if (additional === false) {
+      terms.push({ expr: unclaimed === null ? "false" : `!(${unclaimed})`, usesValue: false });
+    } else {
+      const match = subschemaMatchExpr(valueVar, additional, nest(ctx));
+      if (match === null)
+        return null;
+      if (match !== "true") {
+        terms.push({ expr: unclaimed === null ? match : `(!(${unclaimed}) || ${match})`, usesValue: true });
+      }
+    }
+  }
+  const names = schema["propertyNames"];
+  if (names !== void 0) {
+    const match = subschemaMatchExpr(keyVar, names, nest(ctx));
+    if (match === null)
+      return null;
+    if (match !== "true")
+      terms.push({ expr: match, usesValue: false });
+  }
+  return terms;
+};
+const dependentTerms = (rec, acc, schema, ctx) => {
+  const s = schema;
+  const terms = [];
+  const dependentRequired = s["dependentRequired"];
+  if (typeof dependentRequired === "object" && dependentRequired !== null && !Array.isArray(dependentRequired)) {
+    for (const [trigger, deps] of Object.entries(dependentRequired)) {
+      if (!Array.isArray(deps) || deps.length === 0)
+        continue;
+      const present = deps.map((dep) => hasOwnCheck(rec, dep)).join(" && ");
+      terms.push(`(${missingCheck(rec, trigger)} || ${deps.length === 1 ? present : `(${present})`})`);
+    }
+  }
+  const dependentSchemas = s["dependentSchemas"];
+  if (typeof dependentSchemas === "object" && dependentSchemas !== null && !Array.isArray(dependentSchemas)) {
+    for (const [trigger, sub] of Object.entries(dependentSchemas)) {
+      const match = subschemaMatchExpr(acc, sub, nest(ctx));
+      if (match === null)
+        return null;
+      if (match === "true")
+        continue;
+      terms.push(`(${missingCheck(rec, trigger)} || ${match})`);
+    }
+  }
+  return terms;
+};
+const subschemaMatchExpr = (accessor, schema, ctx = {}) => {
   if (schema === true)
     return "true";
   if (schema === false)
@@ -136,27 +314,41 @@ const subschemaMatchExpr = (accessor, schema, depth = 0) => {
     if (!HANDLED_KEYWORDS.has(key) && !ANNOTATION_KEYWORDS.has(key))
       return null;
   }
-  if ("type" in schema && typeof schema.type !== "string")
+  if (depthOf(ctx) > 8)
     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)}`);
-  }
+  const refCheck = refMatch(accessor, schema, ctx);
+  if (refCheck === null)
+    return null;
+  if (refCheck !== "true")
+    checks.push(refCheck);
+  const combinators = combinatorChecks(accessor, schema, ctx);
+  if (combinators === null)
+    return null;
+  checks.push(...combinators);
+  if (hasConst(schema))
+    checks.push(`(${generateDeepEqualCheck(accessor, schema.const)})`);
   if (hasEnum(schema)) {
     if (schema.enum.length === 0)
-      return null;
+      return "false";
     checks.push(generateEnumCheck(accessor, schema.enum));
   }
   if (hasType(schema)) {
-    const typeChecks = buildTypedChecks(accessor, schema, depth);
+    const typeChecks = buildTypedChecks(accessor, schema, ctx);
     if (typeChecks === null)
       return null;
     checks.push(...typeChecks);
+  } else if (Array.isArray(schema.type)) {
+    const branches = [];
+    for (const type of schema.type) {
+      const branch = buildTypedChecks(accessor, { ...schema, type }, ctx);
+      if (branch === null)
+        return null;
+      branches.push(branch.length === 1 ? branch[0] : `(${branch.join(" && ")})`);
+    }
+    checks.push(branches.length === 0 ? "false" : branches.length === 1 ? branches[0] : `(${branches.join(" || ")})`);
   } else {
-    const typeless = buildTypelessChecks(accessor, schema, depth);
+    const typeless = buildTypelessChecks(accessor, schema, ctx);
     if (typeless === null)
       return null;
     checks.push(...typeless);
@@ -165,7 +357,73 @@ const subschemaMatchExpr = (accessor, schema, depth = 0) => {
     return "true";
   return checks.length === 1 ? checks[0] : `(${checks.join(" && ")})`;
 };
-const buildTypedChecks = (accessor, schema, depth) => {
+const refMatch = (accessor, schema, ctx) => {
+  const ref = schema["$ref"];
+  if (typeof ref !== "string")
+    return "true";
+  if (ctx.rootSchema === void 0)
+    return null;
+  if (ctx.seen?.has(ref))
+    return null;
+  const target = resolveRef(ref, ctx.rootSchema);
+  if (target === void 0)
+    return null;
+  const seen = new Set(ctx.seen ?? []);
+  seen.add(ref);
+  return subschemaMatchExpr(accessor, target, { ...nest(ctx), seen });
+};
+const combinatorChecks = (accessor, schema, ctx) => {
+  const record = schema;
+  const checks = [];
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    const members = record[keyword];
+    if (members === void 0)
+      continue;
+    if (!Array.isArray(members) || members.length === 0)
+      return null;
+    const matches = [];
+    for (const member of members) {
+      const match = subschemaMatchExpr(accessor, member, nest(ctx));
+      if (match === null)
+        return null;
+      matches.push(match);
+    }
+    if (keyword === "allOf") {
+      const constraining = matches.filter((match) => match !== "true");
+      if (constraining.length > 0)
+        checks.push(joinAnd(constraining));
+    } else if (keyword === "anyOf") {
+      if (matches.some((match) => match === "true"))
+        continue;
+      checks.push(matches.length === 1 ? matches[0] : `(${matches.join(" || ")})`);
+    } else {
+      checks.push(matches.length === 1 ? matches[0] : `((${matches.map((match) => `(${match} ? 1 : 0)`).join(" + ")}) === 1)`);
+    }
+  }
+  if ("not" in record) {
+    const match = subschemaMatchExpr(accessor, record["not"], nest(ctx));
+    if (match === null)
+      return null;
+    if (match !== "false")
+      checks.push(`!(${match})`);
+  }
+  if ("if" in record) {
+    const ifMatch = subschemaMatchExpr(accessor, record["if"], nest(ctx));
+    if (ifMatch === null)
+      return null;
+    const branch = (keyword) => keyword in record ? subschemaMatchExpr(accessor, record[keyword], nest(ctx)) : void 0;
+    const thenMatch = branch("then");
+    const elseMatch = branch("else");
+    if (thenMatch === null || elseMatch === null)
+      return null;
+    if (thenMatch !== void 0 && thenMatch !== "true")
+      checks.push(`(!(${ifMatch}) || ${thenMatch})`);
+    if (elseMatch !== void 0 && elseMatch !== "true")
+      checks.push(`((${ifMatch}) || ${elseMatch})`);
+  }
+  return checks;
+};
+const buildTypedChecks = (accessor, schema, ctx) => {
   switch (schema.type) {
     case "string":
       return [`typeof ${accessor} === "string"`, ...stringConstraints(accessor, schema)];
@@ -178,13 +436,13 @@ const buildTypedChecks = (accessor, schema, depth) => {
     case "null":
       return [`${accessor} === null`];
     case "array": {
-      const constraints = arrayConstraints(accessor, schema, depth);
+      const constraints = arrayConstraints(accessor, schema, ctx);
       if (constraints === null)
         return null;
       return [`Array.isArray(${accessor})`, ...constraints];
     }
     case "object": {
-      const constraints = objectConstraints(accessor, schema, depth);
+      const constraints = objectConstraints(accessor, schema, ctx);
       if (constraints === null)
         return null;
       return [isObjectExpr(accessor), ...constraints];
@@ -193,7 +451,7 @@ const buildTypedChecks = (accessor, schema, depth) => {
       return null;
   }
 };
-const buildTypelessChecks = (accessor, schema, depth) => {
+const buildTypelessChecks = (accessor, schema, ctx) => {
   const checks = [];
   const strChecks = stringConstraints(accessor, schema);
   if (strChecks.length > 0)
@@ -201,12 +459,12 @@ const buildTypelessChecks = (accessor, schema, depth) => {
   const numChecks = numberConstraints(accessor, schema, false);
   if (numChecks.length > 0)
     checks.push(`(typeof ${accessor} !== "number" || ${joinAnd(numChecks)})`);
-  const arrChecks = arrayConstraints(accessor, schema, depth);
+  const arrChecks = arrayConstraints(accessor, schema, ctx);
   if (arrChecks === null)
     return null;
   if (arrChecks.length > 0)
     checks.push(`(!Array.isArray(${accessor}) || ${joinAnd(arrChecks)})`);
-  const objChecks = objectConstraints(accessor, schema, depth);
+  const objChecks = objectConstraints(accessor, schema, ctx);
   if (objChecks === null)
     return null;
   if (objChecks.length > 0)
@@ -214,8 +472,14 @@ const buildTypelessChecks = (accessor, schema, depth) => {
   return checks;
 };
 const joinAnd = (checks) => checks.length === 1 ? checks[0] : `(${checks.join(" && ")})`;
-const canMatchSubschema = (schema) => subschemaMatchExpr("_x", schema) !== null;
+const hasConstrainingRefSibling = (schema) => {
+  if (!isSchemaObject(schema) || !("$ref" in schema))
+    return false;
+  return Object.keys(schema).some((key) => key !== "$ref" && !ANNOTATION_KEYWORDS.has(key));
+};
+const canMatchSubschema = (schema, rootSchema) => subschemaMatchExpr("_x", schema, rootSchema ? { rootSchema } : {}) !== null;
 export {
   canMatchSubschema,
+  hasConstrainingRefSibling,
   subschemaMatchExpr
 };

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

@@ -0,0 +1,19 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+import type { MatchContext } from './subschema-match.js';
+type MatchFn = (accessor: string, schema: JSONSchema, ctx: MatchContext) => string | null;
+/**
+ * The `unevaluatedProperties` conjunct for an object accessor: every own key the
+ * schema's other keywords did not evaluate must satisfy the unevaluated
+ * subschema (and `false` means there must be no such key).
+ *
+ * Returns `undefined` when the keyword is absent or constrains nothing (a `true`
+ * schema, or a node whose other keywords already sweep every key), and `null`
+ * when it cannot be proven inline.
+ */
+export declare const unevaluatedPropertiesExpr: (acc: string, schema: JSONSchema, ctx: MatchContext, match: MatchFn) => string | null | undefined;
+/**
+ * The `unevaluatedItems` conjunct for an array accessor — the index counterpart
+ * of {@link unevaluatedPropertiesExpr}.
+ */
+export declare const unevaluatedItemsExpr: (acc: string, schema: JSONSchema, ctx: MatchContext, match: MatchFn) => string | null | undefined;
+export {};