@jarenjs/validate 0.8.4 → 0.34.0

package/src/bigint.js

@@ -0,0 +1,108 @@
+//@ts-check
+
+import {
+  isBigIntType,
+  getBigIntType,
+  getInclusiveExclusiveBounds,
+} from '@jarenjs/core';
+
+import {
+  trueThat,
+} from '@jarenjs/core/function';
+
+function compileBigIntMaximum(schemaObj, jsonSchema) {
+  const [max, emax] = getInclusiveExclusiveBounds(
+    getBigIntType,
+    jsonSchema.maximum,
+    jsonSchema.exclusiveMaximum,
+  );
+
+  if (emax != null) {
+    const addError = schemaObj.createErrorHandler(emax, 'exclusiveMaximum');
+
+    return function validateExclusiveMaximumBigInt(data, dataPath) {
+      return data < emax
+        || addError(data, dataPath);
+    };
+  }
+  else if (max != null) {
+    const addError = schemaObj.createErrorHandler(max, 'maximum');
+
+    return function validateMaximumBigInt(data, dataPath) {
+      return data <= max
+        || addError(data, dataPath);
+    };
+  }
+
+  return undefined;
+}
+
+function compileBigIntMinimum(schemaObj, jsonSchema) {
+  const [min, emin] = getInclusiveExclusiveBounds(
+    getBigIntType,
+    jsonSchema.minimum,
+    jsonSchema.exclusiveMinimum,
+  );
+
+  if (emin != null) {
+    const addError = schemaObj.createErrorHandler(emin, 'exclusiveMinimum');
+
+    return function validateExclusiveMinimumBigInt(data, dataPath) {
+      return data > emin
+        || addError(data, dataPath);
+    };
+  }
+  else if (min != null) {
+    const addError = schemaObj.createErrorHandler(min, 'minimum');
+
+    return function validateMinimumBigInt(data, dataPath) {
+      return data >= min
+        || addError(data, dataPath);
+    };
+  }
+
+  return undefined;
+}
+
+function compileBigIntMultipleOf(schemaObj, jsonSchema) {
+  const mulOf = getBigIntType(jsonSchema.multipleOf);
+  if (mulOf == null) return undefined;
+
+  const addError = schemaObj.createErrorHandler(mulOf, 'multipleOf');
+
+  return function validateMultipleOfBigInt(data, dataPath) {
+    return data % mulOf === BigInt(0)
+      || addError(data, dataPath);
+  };
+}
+
+export function compileBigIntBasic(schemaObj, jsonSchema) {
+  const maximum = compileBigIntMaximum(schemaObj, jsonSchema);
+  const minimum = compileBigIntMinimum(schemaObj, jsonSchema);
+  const multipleOf = compileBigIntMultipleOf(schemaObj, jsonSchema);
+  if (maximum == null && minimum == null && multipleOf == null) return undefined;
+
+  const isMax = maximum || trueThat;
+  const isMin = minimum || trueThat;
+  const isMul = multipleOf || trueThat;
+
+  if (schemaObj.options.skipErrors) {
+    return function validateBigIntSchema(data, dataPath) {
+      if (isBigIntType(data)) {
+        return isMax(data, dataPath)
+          && isMin(data, dataPath)
+          && isMul(data, dataPath);
+      }
+      return true;
+    };
+  }
+
+  // The type guard stays a precondition; the three assertions inside it are
+  // independent and each must get to report its own fault.
+  return function validateBigIntSchemaAll(data, dataPath) {
+    if (!isBigIntType(data)) return true;
+    let valid = isMax(data, dataPath);
+    valid = isMin(data, dataPath) && valid;
+    return isMul(data, dataPath) && valid;
+  };
+}

package/src/combine.js

@@ -0,0 +1,276 @@
+//@ts-check
+
+import {
+  isFn,
+} from '@jarenjs/core';
+
+import {
+  falseThat,
+  trueThat,
+} from '@jarenjs/core/function';
+
+import {
+  combineIndependent,
+  getBoolOrObjectClass,
+  getArrayClassMinItems,
+} from './tools.js';
+
+function compileAllOf(schemaObj, jsonSchema) {
+  const allOf = getArrayClassMinItems(jsonSchema.allOf, 1);
+  if (allOf == null) return undefined;
+
+  const validators = [];
+  for (let i = 0; i < allOf.length; ++i) {
+    const child = allOf[i];
+    if (child === true)
+      validators.push(trueThat);
+    else if (child === false)
+      validators.push(falseThat);
+    else {
+      const validator = schemaObj.createValidator(child, 'allOf', i);
+      validators.push(validator);
+    }
+  }
+  if (validators.length === 0) return undefined;
+
+  const addError = schemaObj.createErrorHandler(allOf, 'allOf');
+
+  const stopAtFirst = schemaObj.options.skipErrors;
+  return function validateAllOf(data, dataPath, dataRoot, dataKey) {
+    if (data !== undefined) {
+      // EVERY allOf branch applies, so every branch's faults are real. Only
+      // the boolean answer may stop at the first failing branch.
+      let valid = true;
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i];
+        if (validator(data, dataPath, dataRoot, dataKey) === false) {
+          valid = addError(data, dataPath);
+          if (stopAtFirst) return valid;
+        }
+      }
+      return valid;
+    }
+    return true;
+  };
+}
+
+function compileAnyOf(schemaObj, jsonSchema) {
+  const anyOf = getArrayClassMinItems(jsonSchema.anyOf, 1);
+  if (anyOf == null) return undefined;
+
+  const validators = [];
+  for (let i = 0; i < anyOf.length; ++i) {
+    const child = anyOf[i];
+    if (child === true)
+      validators.push(trueThat);
+    else if (child === false)
+      validators.push(falseThat);
+    else {
+      const validator = schemaObj.createValidator(child, 'anyOf', i);
+      validators.push(validator);
+    }
+  }
+  if (validators.length === 0) return undefined;
+
+  const addError = schemaObj.createErrorHandler(anyOf, 'anyOf');
+
+  // With annotation tracking every branch must run (annotations from ALL
+  // successful branches count for unevaluated*), and annotations from
+  // failed branches are rolled back.
+  const root = schemaObj.root;
+  if (root.usesUnevaluated) {
+    return function validateAnyOfTracked(data, dataPath, dataRoot, dataKey) {
+      if (data === undefined) return true;
+      const log = root.evalLog;
+      const errors = root.errorMark();
+      let found = false;
+      for (let i = 0; i < validators.length; ++i) {
+        const mark = log.mark();
+        if (validators[i](data, dataPath, dataRoot, dataKey) === true)
+          found = true;
+        else
+          log.rollback(mark);
+      }
+      // Annotation tracking runs every branch, so a match leaves the failed
+      // branches' errors behind unless they are rolled back here too.
+      if (found) root.rollbackErrors(errors);
+      return found || addError(data, dataPath);
+    };
+  }
+
+  return function validateAnyOf(data, dataPath, dataRoot, dataKey) {
+    if (data !== undefined) {
+      // Every branch tried before a match is a SPECULATIVE probe: the document
+      // was never required to satisfy it. Its errors are kept only if no
+      // branch matched at all, where they are the explanation.
+      const mark = root.errorMark();
+      for (let i = 0; i < validators.length; ++i) {
+        if (validators[i](data, dataPath, dataRoot, dataKey) === true) {
+          root.rollbackErrors(mark);
+          return true;
+        }
+      }
+      return addError(data, dataPath);
+    }
+    return true;
+  };
+}
+
+function compileOneOf(schemaObj, jsonSchema) {
+  const oneOf = getArrayClassMinItems(jsonSchema.oneOf, 1);
+  if (oneOf == null)
+    return undefined;
+
+  const validators = [];
+  for (let i = 0; i < oneOf.length; ++i) {
+    const child = oneOf[i];
+    if (child === true)
+      validators.push(trueThat);
+    else if (child === false)
+      validators.push(falseThat);
+    else {
+      const validator = schemaObj.createValidator(child, 'oneOf', i);
+      validators.push(validator);
+    }
+  }
+  if (validators.length === 0)
+    return undefined;
+
+  const addError = schemaObj.createErrorHandler(oneOf, 'oneOf');
+
+  // With annotation tracking, annotations from failed branches are rolled back.
+  const root = schemaObj.root;
+  if (root.usesUnevaluated) {
+    return function validateOneOfTracked(data, dataPath, dataRoot, dataKey) {
+      const log = root.evalLog;
+      const errors = root.errorMark();
+      let found = false;
+      for (let i = 0; i < validators.length; ++i) {
+        const mark = log.mark();
+        if (validators[i](data, dataPath, dataRoot, dataKey) === true) {
+          if (found === true) {
+            root.rollbackErrors(errors);
+            return addError(data, dataPath);
+          }
+          found = true;
+        }
+        else {
+          log.rollback(mark);
+        }
+      }
+      // Non-matching branches were speculative; their complaints survive only
+      // when nothing matched and they are the explanation.
+      if (found) root.rollbackErrors(errors);
+      return found || addError(data, dataPath);
+    };
+  }
+
+  return function validateOneOf(data, dataPath, dataRoot, dataKey) {
+    const errors = root.errorMark();
+    let found = false;
+    for (let i = 0; i < validators.length; ++i) {
+      if (validators[i](data, dataPath, dataRoot, dataKey) === true) {
+        if (found === true) {
+          // Matching twice is the failure; the branches' own errors explain
+          // nothing about it.
+          root.rollbackErrors(errors);
+          return addError(data, dataPath);
+        }
+        found = true;
+      }
+    }
+    if (found) root.rollbackErrors(errors);
+    return found || addError(data, dataPath);
+  };
+}
+
+function compileNotOf(schemaObj, jsonSchema) {
+  const notOf = getBoolOrObjectClass(jsonSchema.not);
+  if (notOf == null) return undefined;
+  if (notOf === false) return trueThat;
+
+  const addError = schemaObj.createErrorHandler(notOf, 'not');
+
+  // `not: true` rejects every instance. It still has to SAY so: returning a
+  // bare false made the only schema that can fail without explanation, and a
+  // collector that reports "invalid" with an empty error list is unusable by
+  // a caller trying to render why.
+  if (notOf === true)
+    return function validateNotOfTrue(data, dataPath) {
+      return data === undefined ? true : addError(data, dataPath);
+    };
+
+  const validate = schemaObj.createValidator(notOf, 'not');
+
+  // Annotations produced inside a 'not' are never kept, whatever the outcome.
+  const root = schemaObj.root;
+  if (root.usesUnevaluated) {
+    return function validateNotOfTracked(data, dataPath, dataRoot, dataKey) {
+      if (data === undefined) return true;
+      const log = root.evalLog;
+      const mark = log.mark();
+      const errors = root.errorMark();
+      const valid = validate(data, dataPath, dataRoot, dataKey);
+      log.rollback(mark);
+      // A `not` whose subschema FAILS is a `not` that passed, so the
+      // subschema's complaints are never the caller's business either way.
+      root.rollbackErrors(errors);
+      return valid === false
+        ? true
+        : addError(data, dataPath);
+    };
+  }
+
+  return function validateNotOf(data, dataPath, dataRoot, dataKey) {
+    if (data === undefined) return true;
+    // The subschema is a probe: its failure is what makes `not` succeed, so
+    // its errors are discarded whichever way the probe went.
+    const errors = root.errorMark();
+    const valid = validate(data, dataPath, dataRoot, dataKey);
+    root.rollbackErrors(errors);
+    return valid === false
+      ? true
+      : addError(data, dataPath);
+  };
+}
+
+export function compileCombineSchema(schemaObj, jsonSchema) {
+  const validators = [];
+  function addValidator(compiler) {
+    if (isFn(compiler))
+      validators.push(compiler);
+  }
+
+  addValidator(compileAllOf(schemaObj, jsonSchema));
+  addValidator(compileAnyOf(schemaObj, jsonSchema));
+  addValidator(compileOneOf(schemaObj, jsonSchema));
+  addValidator(compileNotOf(schemaObj, jsonSchema));
+
+  if (validators.length === 0)
+    return undefined;
+  if (validators.length === 1)
+    return validators[0];
+  // allOf/anyOf/oneOf/not are independent applicator groups: a failing
+  // `oneOf` says nothing about whether `not` also failed.
+  if (!schemaObj.options.skipErrors)
+    return combineIndependent(validators);
+
+  if (validators.length === 2) {
+    const first = validators[0];
+    const second = validators[1];
+    return function validateCombinaSchemaPair(data, dataPath, dataRoot, dataKey) {
+      return first(data, dataPath, dataRoot, dataKey)
+        && second(data, dataPath, dataRoot, dataKey);
+    };
+  }
+  else {
+    return function validateCombineSchema(data, dataPath, dataRoot, dataKey) {
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i];
+        if (validator(data, dataPath, dataRoot, dataKey) === false)
+          return false;
+      }
+      return true;
+    };
+  }
+}

package/src/condition.js

@@ -0,0 +1,129 @@
+//@ts-check
+
+import {
+  fallbackFn,
+} from '@jarenjs/core/function';
+
+import {
+  isObjectClass,
+} from '@jarenjs/core';
+
+import {
+  hasRecursiveAnchor,
+  getDynamicAnchorName,
+} from './dynamic-ref.js';
+
+export function compileConditionSchema(schemaObj, jsonSchema) {
+  const root = schemaObj.root;
+  const validateIf = schemaObj.createValidator(jsonSchema.if, 'if');
+  const tmpThen = schemaObj.createValidator(jsonSchema.then, 'then');
+  const tmpElse = schemaObj.createValidator(jsonSchema.else, 'else');
+
+  if (validateIf == null) return undefined;
+  if (tmpThen == null && tmpElse == null) {
+    // A lone 'if' asserts nothing, but with annotation tracking its
+    // annotations (when it passes) must stay visible to unevaluated*.
+    if (root.usesUnevaluated) {
+      return function validateLoneIf(data, dataPath, dataRoot, dataKey) {
+        const log = root.evalLog;
+        const mark = log.mark();
+        // A lone `if` asserts NOTHING, so it can never explain a failure and
+        // its errors are always discarded. Only its annotations survive, and
+        // only when it passed.
+        const errors = root.errorMark();
+        if (validateIf(data, dataPath, dataRoot, dataKey) === false)
+          log.rollback(mark);
+        root.rollbackErrors(errors);
+        return true;
+      };
+    }
+    return undefined;
+  }
+
+  // Check if then/else schemas have dynamic anchors
+  const thenSchema = jsonSchema.then;
+  const elseSchema = jsonSchema.else;
+  
+  const thenHasRecAnchor = isObjectClass(thenSchema) && hasRecursiveAnchor(thenSchema);
+  const thenDynAnchorName = isObjectClass(thenSchema) ? getDynamicAnchorName(thenSchema) : null;
+  const elseHasRecAnchor = isObjectClass(elseSchema) && hasRecursiveAnchor(elseSchema);
+  const elseDynAnchorName = isObjectClass(elseSchema) ? getDynamicAnchorName(elseSchema) : null;
+  
+  const thenHasAnchor = thenHasRecAnchor || thenDynAnchorName;
+  const elseHasAnchor = elseHasRecAnchor || elseDynAnchorName;
+
+  const validateThen = fallbackFn(tmpThen);
+  const validateElse = fallbackFn(tmpElse);
+
+  // With annotation tracking, annotations produced by a failing 'if' are
+  // rolled back; annotations from a passing 'if' are kept for unevaluated*.
+  if (root.usesUnevaluated && !thenHasAnchor && !elseHasAnchor) {
+    return function validateConditionTracked(data, dataPath, dataRoot, dataKey) {
+      const log = root.evalLog;
+      const mark = log.mark();
+      // `if` decides WHICH branch applies; the document was never required to
+      // satisfy it, so its complaints are discarded either way. Only `then`
+      // and `else` produce errors a caller should see.
+      const errors = root.errorMark();
+      const taken = validateIf(data, dataPath, dataRoot, dataKey);
+      root.rollbackErrors(errors);
+      if (taken) return validateThen(data, dataPath, dataRoot, dataKey);
+      log.rollback(mark);
+      return validateElse(data, dataPath, dataRoot, dataKey);
+    };
+  }
+
+  // If neither then nor else has dynamic anchors, use simple validation
+  if (!thenHasAnchor && !elseHasAnchor) {
+    // Every call site passes (data, dataPath, dataRoot, dataKey). Declaring
+    // fewer parameters does not drop the extra arguments, it MISBINDS them:
+    // a two-parameter form named its second parameter `dataRoot` and was
+    // handed the dataPath, so the branch validators ran with no root at all
+    // and a `$data` reference inside `then` silently resolved to nothing —
+    // a wrong verdict rather than an error.
+    return function validateCondition(data, dataPath, dataRoot, dataKey) {
+      const errors = root.errorMark();
+      const taken = validateIf(data, dataPath, dataRoot, dataKey);
+      root.rollbackErrors(errors);
+      return taken
+        ? validateThen(data, dataPath, dataRoot, dataKey)
+        : validateElse(data, dataPath, dataRoot, dataKey);
+    };
+  }
+  
+  // If then or else has dynamic anchors, wrap validation to register them
+  const track = root.usesUnevaluated;
+  return function validateConditionWithDynamicAnchors(data, dataPath, dataRoot, dataKey) {
+    const mark = track ? root.evalLog.mark() : 0;
+    const conditionErrors = root.errorMark();
+    const taken = validateIf(data, dataPath, dataRoot, dataKey);
+    root.rollbackErrors(conditionErrors);
+    if (taken) {
+      // Validate then branch with dynamic anchor registration
+      if (thenHasAnchor && tmpThen) {
+        const anchorName = thenDynAnchorName || '';
+        root.pushDynamicAnchorValidator(anchorName, tmpThen);
+        try {
+          return validateThen(data, dataPath, dataRoot, dataKey);
+        } finally {
+          root.popDynamicAnchorValidator(anchorName);
+        }
+      }
+      return validateThen(data, dataPath, dataRoot, dataKey);
+    } else {
+      // Annotations from the failed 'if' must not leak to unevaluated*
+      if (track) root.evalLog.rollback(mark);
+      // Validate else branch with dynamic anchor registration
+      if (elseHasAnchor && tmpElse) {
+        const anchorName = elseDynAnchorName || '';
+        root.pushDynamicAnchorValidator(anchorName, tmpElse);
+        try {
+          return validateElse(data, dataPath, dataRoot, dataKey);
+        } finally {
+          root.popDynamicAnchorValidator(anchorName);
+        }
+      }
+      return validateElse(data, dataPath, dataRoot, dataKey);
+    }
+  };
+}

package/src/content.js

@@ -0,0 +1,83 @@
+import {
+  getStringType,
+  isStringType,
+} from '@jarenjs/core';
+
+import {
+  isValidBase64,
+} from '@jarenjs/core/text';
+
+import {
+  isValidJSON,
+} from '@jarenjs/json';
+
+export function compileContentEncoding(schemaObj, jsonSchema) {
+  const encoding = getStringType(jsonSchema.contentEncoding);
+  if (encoding == null) return undefined;
+
+  const addError = schemaObj.createErrorHandler(encoding, 'contentEncoding');
+
+  if (encoding === 'base64') {
+    return function validateBase64(data, dataPath) {
+      // contentEncoding only applies to strings - ignore non-strings
+      if (!isStringType(data)) return true;
+      return isValidBase64(data)
+        || addError(data, dataPath);
+    };
+  }
+
+  // Unknown encoding - treat as valid (per JSON Schema spec)
+  return undefined;
+}
+
+export function compileContentMediaType(schemaObj, jsonSchema) {
+  const mediaType = getStringType(jsonSchema.contentMediaType);
+  if (mediaType == null) return undefined;
+
+  // Check if contentEncoding is also specified
+  const encoding = getStringType(jsonSchema.contentEncoding);
+
+  const addError = schemaObj.createErrorHandler(mediaType, 'contentMediaType');
+
+  if (mediaType === 'application/json') {
+    if (encoding == null) {
+      return function validateJsonContent(data, dataPath) {
+        if (!isStringType(data)) return true;
+        return isValidJSON(data) || addError(data, dataPath);
+      };
+    }
+    else {
+      return function validateBase64JsonContent(data, dataPath) {
+        if (!isStringType(data)) return true;
+        // Check valid base64 first before decoding
+        if (!isValidBase64(data)) return addError(data, dataPath);
+        const decoded = Buffer.from(data, 'base64').toString('utf8');
+        return isValidJSON(decoded) || addError(data, dataPath);
+      }
+    }
+  }
+
+  // Unknown media type - treat as valid (per JSON Schema spec)
+  return undefined;
+}
+
+export function compileContentSchema(schemaObj, jsonSchema) {
+  const encoding = getStringType(jsonSchema.contentEncoding);
+  const mediaType = getStringType(jsonSchema.contentMediaType);
+
+  if (encoding == null && mediaType == null) return undefined;
+
+  // Per JSON Schema 2019-09/2020-12 spec, contentEncoding and contentMediaType
+  // are annotation keywords by default, not assertion keywords.
+  // They only validate when contentValidation option is explicitly enabled.
+  if (!schemaObj.options.contentValidation) {
+    return undefined;
+  }
+
+  const contentEncodingValidator = compileContentEncoding(schemaObj, jsonSchema);
+  const contentMediaTypeValidator = compileContentMediaType(schemaObj, jsonSchema);
+
+  if (!contentEncodingValidator && !contentMediaTypeValidator) return undefined;
+
+  return contentMediaTypeValidator || contentEncodingValidator;
+}

package/src/data.js

@@ -0,0 +1,101 @@
+//@ts-check
+
+/**
+ * @fileoverview Data keyword implementation for referencing instance data.
+ *
+ * This implements the "data" keyword from json-everything's data-2022 meta-schema,
+ * allowing schema values to be sourced from the instance data at validation time.
+ *
+ * Example:
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "A": { "type": "number" },
+ *     "B": {
+ *       "type": "number",
+ *       "data": {
+ *         "minimum": "/A"
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * Supports both absolute JSON Pointers (starting with /) and relative JSON Pointers.
+ * @see https://docs.json-everything.net/schema/examples/data-ref/
+ */
+
+import {
+  isObjectClass,
+  isStringType,
+} from '@jarenjs/core';
+
+import {
+  compileDataRef,
+} from '@jarenjs/json';
+
+import {
+  resolveNothing,
+  createDataRefCompilers,
+} from './tools.js';
+
+function compileRefResolver(ref) {
+  try {
+    return compileDataRef(ref);
+  }
+  catch {
+    return resolveNothing;
+  }
+}
+
+// The fifteen keyword validators are shared with the `$data` keyword;
+// only `compileRefResolver` above differs (see tools.js).
+const KEYWORD_COMPILERS = createDataRefCompilers(compileRefResolver);
+
+/**
+ * Compile the data keyword schema
+ * @param {object} schemaObj - The validation object
+ * @param {object} jsonSchema - The JSON schema containing the data keyword
+ * @returns {function|undefined} The compiled validator function or undefined
+ */
+export function compileDataSchema(schemaObj, jsonSchema) {
+  const dataSchema = jsonSchema.data;
+  if (!isObjectClass(dataSchema)) {
+    return undefined;
+  }
+
+  const validators = [];
+
+  // Compile each supported keyword within the data object
+  for (const [keyword, ref] of Object.entries(dataSchema)) {
+    if (!isStringType(ref)) {
+      continue; // Skip non-string references
+    }
+
+    const compileKeyword = KEYWORD_COMPILERS[keyword];
+    if (compileKeyword === undefined) {
+      continue; // Unknown keyword in data, skip
+    }
+
+    const validator = compileKeyword(schemaObj, ref);
+    if (validator) {
+      validators.push(validator);
+    }
+  }
+
+  if (validators.length === 0) {
+    return undefined;
+  }
+
+  if (validators.length === 1) {
+    return validators[0];
+  }
+
+  return function validateDataSchema(data, dataPath, dataRoot) {
+    for (let i = 0; i < validators.length; i++) {
+      if (!validators[i](data, dataPath, dataRoot)) {
+        return false;
+      }
+    }
+    return true;
+  };
+}