@zohodesk/library-platform 1.2.2 → 1.2.3

package/es/library/json-schema-validator/Validator.js

@@ -0,0 +1,338 @@
+/* eslint-disable complexity */
+export class Validator {
+  static validate(schema, value) {
+    if (schema.schema) {
+      return Validator.validatePropertySchema(schema, value);
+    }
+
+    const errors = [];
+    Validator.validateNode(schema, value, '', errors, schema.definitions || schema.$defs || {});
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings: []
+    };
+  }
+
+  static validateNode(schema, value, dataPath, errors, rootDefinitions) {
+    if (!schema || typeof schema !== 'object') return; // undefined is not a JSON type — skip validation (matches AJV behavior)
+
+    if (value === undefined) return; // $ref resolution
+
+    if (schema.$ref) {
+      const resolved = Validator.resolveRef(schema.$ref, rootDefinitions);
+
+      if (resolved) {
+        Validator.validateNode(resolved, value, dataPath, errors, rootDefinitions);
+      }
+
+      return;
+    } // Hoist definitions from nested schema to root
+
+
+    const definitions = schema.definitions || schema.$defs ? { ...rootDefinitions,
+      ...(schema.definitions || schema.$defs)
+    } : rootDefinitions; // anyOf
+
+    if (schema.anyOf) {
+      const anyOfValid = schema.anyOf.some(subSchema => {
+        const subErrors = [];
+        Validator.validateNode(subSchema, value, dataPath, subErrors, definitions);
+        return subErrors.length === 0;
+      });
+
+      if (!anyOfValid) {
+        errors.push({
+          keyword: 'anyOf',
+          dataPath,
+          message: 'should match at least one schema in anyOf'
+        });
+      }
+
+      return;
+    } // oneOf
+
+
+    if (schema.oneOf) {
+      const matchCount = schema.oneOf.filter(subSchema => {
+        const subErrors = [];
+        Validator.validateNode(subSchema, value, dataPath, subErrors, definitions);
+        return subErrors.length === 0;
+      }).length;
+
+      if (matchCount !== 1) {
+        errors.push({
+          keyword: 'oneOf',
+          dataPath,
+          message: 'should match exactly one schema in oneOf'
+        });
+      }
+
+      return;
+    } // not
+
+
+    if (schema.not) {
+      const notErrors = [];
+      Validator.validateNode(schema.not, value, dataPath, notErrors, definitions);
+
+      if (notErrors.length === 0) {
+        errors.push({
+          keyword: 'not',
+          dataPath,
+          message: 'should NOT match schema in not'
+        });
+      }
+
+      return;
+    } // type validation
+
+
+    if (schema.type) {
+      if (!Validator.checkType(schema.type, value)) {
+        const typeLabel = Array.isArray(schema.type) ? schema.type.join(',') : schema.type;
+        errors.push({
+          keyword: 'type',
+          dataPath,
+          message: `should be ${typeLabel}`
+        });
+        return; // Type mismatch — skip further checks
+      }
+    } // enum
+
+
+    if (schema.enum) {
+      if (!schema.enum.includes(value)) {
+        errors.push({
+          keyword: 'enum',
+          dataPath,
+          message: `should be one of ${JSON.stringify(schema.enum)}`
+        });
+      }
+    } // String constraints
+
+
+    if (typeof value === 'string') {
+      if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push({
+          keyword: 'minLength',
+          dataPath,
+          message: `should have at least ${schema.minLength} characters`
+        });
+      }
+
+      if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push({
+          keyword: 'maxLength',
+          dataPath,
+          message: `should have at most ${schema.maxLength} characters`
+        });
+      }
+
+      if (schema.pattern !== undefined) {
+        const regex = new RegExp(schema.pattern);
+
+        if (!regex.test(value)) {
+          errors.push({
+            keyword: 'pattern',
+            dataPath,
+            message: `should match pattern "${schema.pattern}"`
+          });
+        }
+      }
+    } // Array constraints
+
+
+    if (Array.isArray(value)) {
+      if (schema.minItems !== undefined && value.length < schema.minItems) {
+        errors.push({
+          keyword: 'minItems',
+          dataPath,
+          message: `should have at least ${schema.minItems} items`
+        });
+      }
+
+      if (schema.uniqueItems === true) {
+        const seen = new Set();
+        const hasDuplicates = value.some(item => {
+          const key = typeof item === 'object' ? JSON.stringify(item) : item;
+          if (seen.has(key)) return true;
+          seen.add(key);
+          return false;
+        });
+
+        if (hasDuplicates) {
+          errors.push({
+            keyword: 'uniqueItems',
+            dataPath,
+            message: 'should have unique items'
+          });
+        }
+      }
+
+      if (schema.items) {
+        value.forEach((item, index) => {
+          Validator.validateNode(schema.items, item, `${dataPath}[${index}]`, errors, definitions);
+        });
+      }
+    } // Object constraints
+
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      if (schema.required) {
+        schema.required.forEach(key => {
+          if (!(key in value)) {
+            const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+            errors.push({
+              keyword: 'required',
+              dataPath: propPath,
+              message: `should have required property '${key}'`
+            });
+          }
+        });
+      }
+
+      if (schema.properties) {
+        for (const key in schema.properties) {
+          if (key in value) {
+            const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+            Validator.validateNode(schema.properties[key], value[key], propPath, errors, definitions);
+          }
+        }
+      }
+
+      if (schema.additionalProperties !== undefined && schema.additionalProperties !== true && schema.properties) {
+        const allowed = new Set(Object.keys(schema.properties));
+
+        for (const key in value) {
+          if (!allowed.has(key)) {
+            if (schema.additionalProperties === false) {
+              const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+              errors.push({
+                keyword: 'additionalProperties',
+                dataPath: propPath,
+                message: `should NOT have additional property '${key}'`
+              });
+            } else if (typeof schema.additionalProperties === 'object') {
+              const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+              Validator.validateNode(schema.additionalProperties, value[key], propPath, errors, definitions);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  static checkType(type, value) {
+    if (Array.isArray(type)) {
+      return type.some(t => Validator.checkSingleType(t, value));
+    }
+
+    return Validator.checkSingleType(type, value);
+  }
+
+  static checkSingleType(type, value) {
+    switch (type) {
+      case 'string':
+        return typeof value === 'string';
+
+      case 'number':
+        return typeof value === 'number';
+
+      case 'boolean':
+        return typeof value === 'boolean';
+
+      case 'object':
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+
+      case 'array':
+        return Array.isArray(value);
+
+      case 'null':
+        return value === null;
+
+      case 'function':
+        return typeof value === 'function';
+
+      default:
+        return true;
+      // 'any' or unknown types — accept anything
+    }
+  }
+
+  static resolveRef(ref, definitions) {
+    // Supports: #/definitions/Name and #/$defs/Name
+    const match = ref.match(/^#\/(definitions|\$defs)\/(.+)$/);
+
+    if (match && definitions[match[2]]) {
+      return definitions[match[2]];
+    }
+
+    return null;
+  }
+
+  static validatePropertySchema(propertySchema, value) {
+    const {
+      schema
+    } = propertySchema;
+    const result = Validator.validateRequired(propertySchema, value);
+    const isProvided = propertySchema.isValueProvided;
+
+    if (result.isValid === false) {
+      return result;
+    }
+
+    if (!isProvided) {
+      return {
+        isValid: true,
+        errors: [],
+        warnings: result.warnings
+      };
+    }
+
+    const {
+      isValid,
+      errors,
+      warnings
+    } = Validator.validate(schema, value);
+    return {
+      key: propertySchema.name,
+      isValid,
+      errors,
+      warnings: [...result.warnings, ...warnings]
+    };
+  }
+
+  static validateRequired(propertySchema, value) {
+    const errors = [];
+    const warnings = [];
+    const isRequired = propertySchema.required === true;
+    const hasDefault = Object.prototype.hasOwnProperty.call(propertySchema, 'defaultValue');
+    const isProvided = propertySchema.isValueProvided;
+
+    if (!isProvided && isRequired) {
+      if (hasDefault) {
+        if (propertySchema.defaultValue === undefined) {
+          errors.push({
+            message: `is required but missing. So, default value is undefined.`
+          });
+        } else {
+          warnings.push({
+            message: `is required but missing. So, Default value will be used.`
+          });
+        }
+      } else {
+        errors.push({
+          message: `is required but missing. And, neither a value nor a default value is present.`
+        });
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      warnings,
+      errors
+    };
+  }
+
+}