@jarenjs/validate 0.8.4 → 0.9.2

package/src/combine.js

@@ -0,0 +1,226 @@
+//@ts-check
+
+import {
+  isFn,
+} from '@jarenjs/core';
+
+import {
+  falseThat,
+  trueThat,
+} from '@jarenjs/core/function';
+
+import {
+  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');
+
+  return function validateAllOf(data, dataPath, dataRoot, dataKey) {
+    if (data !== undefined) {
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i];
+        if (validator(data, dataPath, dataRoot, dataKey) === false) {
+          return addError(data, dataPath);
+        }
+      }
+    }
+    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;
+      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);
+      }
+      return found || addError(data, dataPath);
+    };
+  }
+
+  return function validateAnyOf(data, dataPath, dataRoot, dataKey) {
+    if (data !== undefined) {
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i]; // TODO: how to silence errors of children?
+        if (validator(data, dataPath, dataRoot, dataKey) === true) 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;
+      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)
+            return addError(data, dataPath);
+          found = true;
+        }
+        else {
+          log.rollback(mark);
+        }
+      }
+      return found || addError(data, dataPath);
+    };
+  }
+
+  return function validateOneOf(data, dataPath, dataRoot, dataKey) {
+    let found = false;
+    for (let i = 0; i < validators.length; ++i) {
+      const validator = validators[i];
+      if (validator(data, dataPath, dataRoot, dataKey) === true) {
+        if (found === true)
+          return addError(data, dataPath);
+        found = true;
+      }
+    }
+    return found || addError(data, dataPath);
+  };
+}
+
+function compileNotOf(schemaObj, jsonSchema) {
+  const notOf = getBoolOrObjectClass(jsonSchema.not);
+  if (notOf == null) return undefined;
+  if (notOf === true) return falseThat;
+  if (notOf === false) return trueThat;
+
+  const validate = schemaObj.createValidator(notOf, 'not');
+
+  const addError = schemaObj.createErrorHandler(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 valid = validate(data, dataPath, dataRoot, dataKey);
+      log.rollback(mark);
+      return valid === false
+        ? true
+        : addError(data, dataPath);
+    };
+  }
+
+  return function validateNotOf(data, dataPath, dataRoot, dataKey) {
+    if (data === undefined) return true;
+    return validate(data, dataPath, dataRoot, dataKey) === 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];
+  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,109 @@
+//@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();
+        if (validateIf(data, dataPath, dataRoot, dataKey) === false)
+          log.rollback(mark);
+        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 (validateIf(data, dataPath, dataRoot, dataKey)) {
+        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) {
+    return function validateCondition(data, dataRoot) {
+      if (validateIf(data))
+        return validateThen(data, dataRoot);
+      else
+        return validateElse(data, dataRoot);
+    };
+  }
+  
+  // If then or else has dynamic anchors, wrap validation to register them
+  const track = root.usesUnevaluated;
+  return function validateConditionWithDynamicAnchors(data, dataPath, dataRoot) {
+    const mark = track ? root.evalLog.mark() : 0;
+    if (validateIf(data)) {
+      // Validate then branch with dynamic anchor registration
+      if (thenHasAnchor && tmpThen) {
+        const anchorName = thenDynAnchorName || '';
+        root.pushDynamicAnchorValidator(anchorName, tmpThen);
+        try {
+          return validateThen(data, dataRoot);
+        } finally {
+          root.popDynamicAnchorValidator(anchorName);
+        }
+      }
+      return validateThen(data, dataRoot);
+    } 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, dataRoot);
+        } finally {
+          root.popDynamicAnchorValidator(anchorName);
+        }
+      }
+      return validateElse(data, dataRoot);
+    }
+  };
+}

package/src/content.js

@@ -0,0 +1,83 @@
+import {
+  getStringType,
+  isStringType,
+} from '@jarenjs/core';
+
+import {
+  isValidBase64Fast,
+} 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 isValidBase64Fast(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 (!isValidBase64Fast(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;
+}