@jarenjs/validate 0.9.2 → 0.34.0

package/src/tools.js

@@ -23,6 +23,14 @@ import {
   isArrayish,
 } from '@jarenjs/core/array';
 
+import {
+  isJsonObject,
+} from '@jarenjs/core/object';
+
+import {
+  JSONPOINTER_NOTHING,
+} from '@jarenjs/json';
+
 //#region Object
 export function isBoolOrObjectClass(obj) {
   return isBooleanType(obj)
@@ -77,6 +85,32 @@ export function hasSchemaDynamicRef(schema) {
     && !isStringWhiteSpace(schema.$dynamicRef);
 }
 
+/**
+ * Whether a sibling keyword of unevaluatedProperties already evaluates every
+ * property of the instance. additionalProperties (boolean or schema) applies
+ * to each property not matched by properties/patternProperties, so once it
+ * has passed no property is left unevaluated.
+ * @param {object} schema - The schema holding the unevaluatedProperties keyword
+ * @returns {boolean} True when the unevaluatedProperties check can never match
+ */
+export function hasUnevaluatedPropertiesCoverage(schema) {
+  return isBoolOrObjectClass(schema.additionalProperties);
+}
+
+/**
+ * Whether a sibling keyword of unevaluatedItems already evaluates every item
+ * of the instance: a uniform items schema (boolean or object) covers all
+ * items beyond any prefixItems, and a tuple-form items with additionalItems
+ * covers the items beyond the tuple.
+ * @param {object} schema - The schema holding the unevaluatedItems keyword
+ * @returns {boolean} True when the unevaluatedItems check can never match
+ */
+export function hasUnevaluatedItemsCoverage(schema) {
+  const items = schema.items;
+  if (isBoolOrObjectClass(items)) return true;
+  return isArrayClass(items) && isBoolOrObjectClass(schema.additionalItems);
+}
+
 export function createIsSchemaTypeHandler(type, isStrict = false) {
   switch (type) {
     case 'null': return isNullValue;
@@ -109,6 +143,137 @@ export function createIsSchemaTypeHandler(type, isStrict = false) {
 
 //#endregion
 
+//#region Data references
+
+/**
+ * The fallback resolver of the data-reference keywords (`data`, `$data`):
+ * a ref that fails the strict compile keeps the lax keyword semantics, so
+ * it resolves as not-found and the keyword asserts nothing.
+ * @returns {any} the JSON Pointer not-found sentinel
+ */
+export const resolveNothing = () => JSONPOINTER_NOTHING;
+
+const isDefined = (data) => data !== undefined;
+const isJsonString = (data) => typeof data === 'string';
+const isAnyValue = () => true;
+
+/**
+ * Build the keyword validators the two data-reference keywords share
+ * verbatim. The `data` keyword (json-everything, absolute + relative
+ * pointers via `compileDataRef`) and the Ajv-style `$data` keyword
+ * (relative pointers only) differ ONLY in which pointer compiler
+ * resolves a ref, so each module passes its own `compileRefResolver`
+ * and gets the same fifteen compilers back.
+ *
+ * Every validator follows one lax contract: a data instance outside the
+ * keyword's type, an unresolvable ref, or a resolved constraint of the
+ * wrong type asserts nothing.
+ *
+ * @param {(ref: string) => (dataRoot: any, dataPath: string) => any} compileRefResolver
+ * @returns {Record<string, (schemaObj: object, ref: string) => ((data: any, dataPath: string, dataRoot: any) => boolean) | undefined>}
+ */
+export function createDataRefCompilers(compileRefResolver) {
+  /**
+   * @param {string} keyword
+   * @param {(data: any) => boolean} accepts - Instance types the keyword constrains
+   * @param {(constraint: any) => boolean} expects - Resolved constraint types that assert
+   * @param {(data: any, constraint: any) => boolean} isValid
+   */
+  const constraint = (keyword, accepts, expects, isValid) =>
+    (schemaObj, ref) => {
+      const addError = schemaObj.createErrorHandler(ref, keyword);
+      const resolveRef = compileRefResolver(ref);
+
+      return function validateDataRefConstraint(data, dataPath, dataRoot) {
+        if (!accepts(data)) return true;
+
+        const value = resolveRef(dataRoot, dataPath);
+        if (value === JSONPOINTER_NOTHING || !expects(value)) return true;
+
+        return isValid(data, value) || addError(data, dataPath, value);
+      };
+    };
+
+  const compileFormat = (schemaObj, ref) => {
+    const formats = schemaObj.formats;
+    if (!formats) return undefined;
+
+    const addError = schemaObj.createErrorHandler(ref, 'format');
+    const resolveRef = compileRefResolver(ref);
+
+    // The registry holds format COMPILERS; compile (and cache) a validator
+    // per referenced format name at validation time.
+    const compiled = new Map();
+    const mockSchemaObj = {
+      createErrorHandler: () => () => false,
+      options: { skipErrors: true },
+    };
+
+    return function validateDataRefFormat(data, dataPath, dataRoot) {
+      if (typeof data !== 'string') return true;
+
+      const formatName = resolveRef(dataRoot, dataPath);
+      if (formatName === JSONPOINTER_NOTHING || !isStringType(formatName)) return true;
+
+      let validator = compiled.get(formatName);
+      if (validator === undefined) {
+        const formatCompiler = formats[formatName];
+        validator = null;
+        if (formatCompiler) {
+          try {
+            const candidate = formatCompiler(mockSchemaObj, { format: formatName });
+            if (typeof candidate === 'function') validator = candidate;
+          } catch (_e) {
+            // An uncompilable format asserts nothing
+          }
+        }
+        compiled.set(formatName, validator);
+      }
+      if (validator === null) return true;
+
+      return validator(data, dataPath) || addError(data, dataPath, formatName);
+    };
+  };
+
+  return {
+    __proto__: null,
+    minimum: constraint('minimum', isNumberType, isNumberType,
+      (data, min) => data >= min),
+    maximum: constraint('maximum', isNumberType, isNumberType,
+      (data, max) => data <= max),
+    exclusiveMinimum: constraint('exclusiveMinimum', isNumberType, isNumberType,
+      (data, min) => data > min),
+    exclusiveMaximum: constraint('exclusiveMaximum', isNumberType, isNumberType,
+      (data, max) => data < max),
+    multipleOf: constraint('multipleOf', isNumberType, isNumberType,
+      (data, multipleOf) => {
+        const q = data / multipleOf;
+        return Math.abs(q - Math.round(q)) < 1e-6;
+      }),
+    minLength: constraint('minLength', isJsonString, isNumberType,
+      (data, min) => data.length >= min),
+    maxLength: constraint('maxLength', isJsonString, isNumberType,
+      (data, max) => data.length <= max),
+    pattern: constraint('pattern', isJsonString, isStringType,
+      (data, pattern) => new RegExp(pattern, 'u').test(data)),
+    minItems: constraint('minItems', Array.isArray, isNumberType,
+      (data, min) => data.length >= min),
+    maxItems: constraint('maxItems', Array.isArray, isNumberType,
+      (data, max) => data.length <= max),
+    minProperties: constraint('minProperties', isJsonObject, isNumberType,
+      (data, min) => Object.keys(data).length >= min),
+    maxProperties: constraint('maxProperties', isJsonObject, isNumberType,
+      (data, max) => Object.keys(data).length <= max),
+    enum: constraint('enum', isDefined, Array.isArray,
+      (data, values) => values.includes(data)),
+    const: constraint('const', isDefined, isAnyValue,
+      (data, value) => data === value),
+    format: compileFormat,
+  };
+}
+
+//#endregion
+
 /**
  * Records which properties (string keys) and items (numeric indexes) of a
  * data instance were successfully evaluated during validation, so that
@@ -174,6 +339,33 @@ export class EvalLog {
   }
 }
 
+/**
+ * Combine INDEPENDENT keyword validators without short-circuiting.
+ *
+ * `a(...) && b(...)` is the right composition in boolean mode: the answer is
+ * known at the first failure and nothing is gained by continuing. When errors
+ * are recorded it is wrong, because each validator is the only thing that can
+ * report its own fault, so the first failure hides every sibling's. This runs
+ * all of them and ANDs the results — the boolean answer is identical, the
+ * error list is complete.
+ *
+ * Only use it where the validators genuinely are independent. A precondition
+ * (a type guard before a length check) must keep its short-circuit: running
+ * past it is meaningless at best and throws at worst.
+ * @param {Function[]} validators - Independent validators, in report order
+ * @returns {Function} A validator that runs every one of them
+ */
+export function combineIndependent(validators) {
+  return function validateIndependent(data, dataPath, dataRoot, dataKey) {
+    let valid = true;
+    for (let i = 0; i < validators.length; ++i) {
+      if (validators[i](data, dataPath, dataRoot, dataKey) === false)
+        valid = false;
+    }
+    return valid;
+  };
+}
+
 export class ValidationResult {
   static undefThat() {
     return new ValidationResult();

package/src/traverse.js

@@ -20,9 +20,14 @@ import {
   isValidHtmlIdentifier,
 } from '@jarenjs/core/text';
 
+import {
+  encodeJSONPointerSegment,
+  decodeJSONPointerSegment,
+} from '@jarenjs/json/pointer';
+
 
 function encodeJsonPointerKey(key) {
-  return encodeURIComponent(key.replace('~', '~0').replace('/', '~1'));
+  return encodeURIComponent(encodeJSONPointerSegment(key));
 }
 
 export function encodeJsonPointerPath(path, key, index) {
@@ -32,7 +37,11 @@ export function encodeJsonPointerPath(path, key, index) {
 }
 
 function decodeJsonPointerKey(key) {
-  return decodeURIComponent(key.replace('~0', '~').replace('~1', '/'));
+  // Lenient decode: `$ref` fragments arrive here unvalidated, so a stray
+  // `~` must pass through instead of throwing like the strict parser does.
+  // The percent-decode is this site's own: these keys arrive from a URI
+  // fragment, which the plain reference-token decode knows nothing about.
+  return decodeJSONPointerSegment(decodeURIComponent(key));
 }
 
 export function decodeJsonPointerPath(path) {
@@ -80,7 +89,7 @@ export function createJsonPointer(refUri, baseUri, opts = new JsonPointerOptions
         url = new URL(refUri, 'http://example.com/' + effectiveBase);
         // Restore the original baseUri in the result
         const href = url.href.replace('http://example.com/', '');
-        const [uri, fragment] = href.split('#');
+        const [, fragment] = href.split('#');
         return new JsonPointer(
           effectiveBase + refUri,
           undefined,
@@ -364,7 +373,7 @@ export function restoreSchemaRefsInMap(schemas, opts = new JsonPointerOptions())
       if (finalId !== id && !schemas.has(finalId)) {
         schemas.set(finalId, finalSchema);
       }
-    } catch (e) {
+    } catch (_e) {
       // If deep resolution fails (remote ref not loaded), fall back to shallow resolution
       // This preserves the original behavior for unresolved refs
       const { schema } = resolveRefSchemaShallow(schemas, id, null, opts);

package/src/unevaluated.js

@@ -7,6 +7,8 @@ import {
 
 import {
   getBoolOrObjectClass,
+  hasUnevaluatedPropertiesCoverage,
+  hasUnevaluatedItemsCoverage,
 } from './tools.js';
 
 /**
@@ -22,13 +24,20 @@ function compileUnevaluatedProperties(schemaObj, jsonSchema) {
   const uneval = getBoolOrObjectClass(jsonSchema.unevaluatedProperties);
   if (uneval == null) return undefined;
 
+  // In skipErrors mode reaching this final-stage check means every sibling
+  // keyword passed; with a sibling additionalProperties every property was
+  // then evaluated (and logged), so the check can never match and the
+  // sibling already produced the annotations any outer check consumes.
+  if (schemaObj.options.skipErrors && hasUnevaluatedPropertiesCoverage(jsonSchema))
+    return undefined;
+
   const root = schemaObj.root;
   const addError = schemaObj.createErrorHandler(uneval, 'unevaluatedProperties');
 
   // true: everything left over is valid, but counts as evaluated for
   // any unevaluatedProperties in an outer schema.
   if (uneval === true) {
-    return function validateUnevaluatedPropertiesTrue(data, dataPath, dataRoot, mark) {
+    return function validateUnevaluatedPropertiesTrue(data, _dataPath, _dataRoot, _mark) {
       if (!isObjectType(data)) return true;
       const log = root.evalLog;
       const keys = Object.keys(data);
@@ -81,11 +90,19 @@ function compileUnevaluatedItems(schemaObj, jsonSchema) {
   const uneval = getBoolOrObjectClass(jsonSchema.unevaluatedItems);
   if (uneval == null) return undefined;
 
+  // In skipErrors mode reaching this final-stage check means every sibling
+  // keyword passed; with sibling coverage (uniform items, or tuple items
+  // plus additionalItems) every item was then evaluated (and logged), so
+  // the check can never match and the covering sibling already produced
+  // the annotations any outer check consumes.
+  if (schemaObj.options.skipErrors && hasUnevaluatedItemsCoverage(jsonSchema))
+    return undefined;
+
   const root = schemaObj.root;
   const addError = schemaObj.createErrorHandler(uneval, 'unevaluatedItems');
 
   if (uneval === true) {
-    return function validateUnevaluatedItemsTrue(data, dataPath, dataRoot, mark) {
+    return function validateUnevaluatedItemsTrue(data, _dataPath, _dataRoot, _mark) {
       if (!isArrayClass(data)) return true;
       root.evalLog.add(data, -1);
       return true;
@@ -140,12 +157,17 @@ export function wrapUnevaluated(schemaObj, jsonSchema, validator) {
   const unevalItems = compileUnevaluatedItems(schemaObj, jsonSchema);
   if (unevalProps == null && unevalItems == null) return validator;
 
+  const stopAtFirst = root.options.skipErrors;
   return function validateUnevaluatedSchema(data, dataPath, dataRoot, dataKey) {
     const log = root.evalLog;
     const mark = log.mark();
+    // The sibling result IS a precondition: unevaluated* reads annotations
+    // that a failed sibling may never have produced. But unevaluatedProperties
+    // and unevaluatedItems are independent of each other.
     if (validator(data, dataPath, dataRoot, dataKey) === false) return false;
-    if (unevalProps != null && unevalProps(data, dataPath, dataRoot, mark) === false) return false;
-    if (unevalItems != null && unevalItems(data, dataPath, dataRoot, mark) === false) return false;
-    return true;
+    let valid = unevalProps == null || unevalProps(data, dataPath, dataRoot, mark) !== false;
+    if (stopAtFirst && !valid) return false;
+    if (unevalItems != null && unevalItems(data, dataPath, dataRoot, mark) === false) valid = false;
+    return valid;
   };
 }