@jarenjs/validate 0.9.2 → 0.34.2

package/src/data.js

@@ -27,18 +27,16 @@
 import {
   isObjectClass,
   isStringType,
-  isNumberType,
-  isArrayClass,
 } from '@jarenjs/core';
 
 import {
   compileDataRef,
-  JSONPOINTER_NOTHING,
 } from '@jarenjs/json';
 
-// A ref that fails the strict compile keeps the lax keyword semantics:
-// it resolves as not-found and the keyword asserts nothing.
-const resolveNothing = () => JSONPOINTER_NOTHING;
+import {
+  resolveNothing,
+  createDataRefCompilers,
+} from './tools.js';
 
 function compileRefResolver(ref) {
   try {
@@ -49,336 +47,9 @@ function compileRefResolver(ref) {
   }
 }
 
-/**
- * Compile minimum constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMinimum(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'minimum');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMinimum(data, dataPath, dataRoot) {
-    if (!isNumberType(data)) return true;
-
-    const minValue = resolveRef(dataRoot, dataPath);
-    if (minValue === JSONPOINTER_NOTHING || !isNumberType(minValue)) return true;
-
-    return data >= minValue || addError(minValue, data, dataPath);
-  };
-}
-
-/**
- * Compile maximum constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMaximum(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'maximum');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMaximum(data, dataPath, dataRoot) {
-    if (!isNumberType(data)) return true;
-
-    const maxValue = resolveRef(dataRoot, dataPath);
-    if (maxValue === JSONPOINTER_NOTHING || !isNumberType(maxValue)) return true;
-
-    return data <= maxValue || addError(maxValue, data, dataPath);
-  };
-}
-
-/**
- * Compile exclusiveMinimum constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataExclusiveMinimum(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'exclusiveMinimum');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataExclusiveMinimum(data, dataPath, dataRoot) {
-    if (!isNumberType(data)) return true;
-
-    const minValue = resolveRef(dataRoot, dataPath);
-    if (minValue === JSONPOINTER_NOTHING || !isNumberType(minValue)) return true;
-
-    return data > minValue || addError(minValue, data, dataPath);
-  };
-}
-
-/**
- * Compile exclusiveMaximum constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataExclusiveMaximum(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'exclusiveMaximum');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataExclusiveMaximum(data, dataPath, dataRoot) {
-    if (!isNumberType(data)) return true;
-
-    const maxValue = resolveRef(dataRoot, dataPath);
-    if (maxValue === JSONPOINTER_NOTHING || !isNumberType(maxValue)) return true;
-
-    return data < maxValue || addError(maxValue, data, dataPath);
-  };
-}
-
-/**
- * Compile enum constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataEnum(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'enum');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataEnum(data, dataPath, dataRoot) {
-    if (data === undefined) return true;
-
-    const enumValues = resolveRef(dataRoot, dataPath);
-    if (enumValues === JSONPOINTER_NOTHING || !Array.isArray(enumValues)) return true;
-
-    return enumValues.includes(data) || addError(enumValues, data, dataPath);
-  };
-}
-
-/**
- * Compile const constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataConst(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'const');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataConst(data, dataPath, dataRoot) {
-    if (data === undefined) return true;
-
-    const constValue = resolveRef(dataRoot, dataPath);
-    if (constValue === JSONPOINTER_NOTHING) return true;
-
-    return data === constValue || addError(constValue, data, dataPath);
-  };
-}
-
-/**
- * Compile minLength constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMinLength(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'minLength');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMinLength(data, dataPath, dataRoot) {
-    if (typeof data !== 'string') return true;
-
-    const minLen = resolveRef(dataRoot, dataPath);
-    if (minLen === JSONPOINTER_NOTHING || !isNumberType(minLen)) return true;
-
-    return data.length >= minLen || addError(minLen, data, dataPath);
-  };
-}
-
-/**
- * Compile maxLength constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMaxLength(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'maxLength');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMaxLength(data, dataPath, dataRoot) {
-    if (typeof data !== 'string') return true;
-
-    const maxLen = resolveRef(dataRoot, dataPath);
-    if (maxLen === JSONPOINTER_NOTHING || !isNumberType(maxLen)) return true;
-
-    return data.length <= maxLen || addError(maxLen, data, dataPath);
-  };
-}
-
-/**
- * Compile minItems constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMinItems(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'minItems');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMinItems(data, dataPath, dataRoot) {
-    if (!Array.isArray(data)) return true;
-
-    const minItems = resolveRef(dataRoot, dataPath);
-    if (minItems === JSONPOINTER_NOTHING || !isNumberType(minItems)) return true;
-
-    return data.length >= minItems || addError(minItems, data, dataPath);
-  };
-}
-
-/**
- * Compile maxItems constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMaxItems(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'maxItems');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMaxItems(data, dataPath, dataRoot) {
-    if (!Array.isArray(data)) return true;
-
-    const maxItems = resolveRef(dataRoot, dataPath);
-    if (maxItems === JSONPOINTER_NOTHING || !isNumberType(maxItems)) return true;
-
-    return data.length <= maxItems || addError(maxItems, data, dataPath);
-  };
-}
-
-/**
- * Compile minProperties constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMinProperties(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'minProperties');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMinProperties(data, dataPath, dataRoot) {
-    if (typeof data !== 'object' || data === null || Array.isArray(data)) return true;
-
-    const minProps = resolveRef(dataRoot, dataPath);
-    if (minProps === JSONPOINTER_NOTHING || !isNumberType(minProps)) return true;
-
-    const propCount = Object.keys(data).length;
-    return propCount >= minProps || addError(minProps, data, dataPath);
-  };
-}
-
-/**
- * Compile maxProperties constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMaxProperties(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'maxProperties');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMaxProperties(data, dataPath, dataRoot) {
-    if (typeof data !== 'object' || data === null || Array.isArray(data)) return true;
-
-    const maxProps = resolveRef(dataRoot, dataPath);
-    if (maxProps === JSONPOINTER_NOTHING || !isNumberType(maxProps)) return true;
-
-    const propCount = Object.keys(data).length;
-    return propCount <= maxProps || addError(maxProps, data, dataPath);
-  };
-}
-
-/**
- * Compile multipleOf constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataMultipleOf(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'multipleOf');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataMultipleOf(data, dataPath, dataRoot) {
-    if (!isNumberType(data)) return true;
-
-    const multipleOf = resolveRef(dataRoot, dataPath);
-    if (multipleOf === JSONPOINTER_NOTHING || !isNumberType(multipleOf)) return true;
-
-    const q = data / multipleOf;
-    return Math.abs(q - Math.round(q)) < 1e-6 || addError(multipleOf, data, dataPath);
-  };
-}
-
-/**
- * Compile pattern constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataPattern(schemaObj, ref) {
-  const addError = schemaObj.createErrorHandler(ref, 'pattern');
-  const resolveRef = compileRefResolver(ref);
-
-  return function validateDataPattern(data, dataPath, dataRoot) {
-    if (typeof data !== 'string') return true;
-
-    const pattern = resolveRef(dataRoot, dataPath);
-    if (pattern === JSONPOINTER_NOTHING || !isStringType(pattern)) return true;
-
-    const regex = new RegExp(pattern, 'u');
-    return regex.test(data) || addError(pattern, data, dataPath);
-  };
-}
-
-/**
- * Compile format constraint from data reference
- * @param {object} schemaObj - The validation object
- * @param {string} ref - The data reference
- * @returns {function|undefined} The compiled validator function
- */
-function compileDataFormat(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 validateDataFormat(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(formatName, data, dataPath);
-  };
-}
+// 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
@@ -400,59 +71,12 @@ export function compileDataSchema(schemaObj, jsonSchema) {
       continue; // Skip non-string references
     }
 
-    let validator;
-
-    switch (keyword) {
-      case 'minimum':
-        validator = compileDataMinimum(schemaObj, ref);
-        break;
-      case 'maximum':
-        validator = compileDataMaximum(schemaObj, ref);
-        break;
-      case 'exclusiveMinimum':
-        validator = compileDataExclusiveMinimum(schemaObj, ref);
-        break;
-      case 'exclusiveMaximum':
-        validator = compileDataExclusiveMaximum(schemaObj, ref);
-        break;
-      case 'enum':
-        validator = compileDataEnum(schemaObj, ref);
-        break;
-      case 'const':
-        validator = compileDataConst(schemaObj, ref);
-        break;
-      case 'minLength':
-        validator = compileDataMinLength(schemaObj, ref);
-        break;
-      case 'maxLength':
-        validator = compileDataMaxLength(schemaObj, ref);
-        break;
-      case 'minItems':
-        validator = compileDataMinItems(schemaObj, ref);
-        break;
-      case 'maxItems':
-        validator = compileDataMaxItems(schemaObj, ref);
-        break;
-      case 'minProperties':
-        validator = compileDataMinProperties(schemaObj, ref);
-        break;
-      case 'maxProperties':
-        validator = compileDataMaxProperties(schemaObj, ref);
-        break;
-      case 'multipleOf':
-        validator = compileDataMultipleOf(schemaObj, ref);
-        break;
-      case 'pattern':
-        validator = compileDataPattern(schemaObj, ref);
-        break;
-      case 'format':
-        validator = compileDataFormat(schemaObj, ref);
-        break;
-      default:
-        // Unknown keyword in data, skip
-        break;
+    const compileKeyword = KEYWORD_COMPILERS[keyword];
+    if (compileKeyword === undefined) {
+      continue; // Unknown keyword in data, skip
     }
 
+    const validator = compileKeyword(schemaObj, ref);
     if (validator) {
       validators.push(validator);
     }