@hsui/sdk/lib/utils/is-json-valid.js

Hundsun frontend framework JSSDK

import _typeof from "@babel/runtime/helpers/esm/typeof";
/** 根据传入的 schema 校验对象是否符合要求
 * 校验对象支持 object 类型，对象的属性支持 string number object array 类型
 * import validator from './is-json-valid';
 * const it = validator(schema); 返回一个函数
 * it(data); 传入需要校验的对象
 * it.errors;
 */

function compile(schema, opts) {
  var validate = function validate(data) {
    validate.errors = null;
    var type = schema.type;
    var errors = [];
    // 判断对象类型的参数
    if (type === 'object') {
      var dataType = _typeof(data);
      dataType === 'object' && (dataType = Array.isArray(data) ? 'array' : 'object');
      if (dataType !== 'object') {
        errors.push({
          field: 'data',
          message: 'is the wrong type',
          schemaPath: [],
          type: 'object',
          value: data
        });
      } else {
        var schemaPropertiesKeys = Object.keys(schema.properties);
        // 循环 schema 的 key
        for (var i = 0; i < schemaPropertiesKeys.length; i++) {
          var schemaItemRules = schema.properties[schemaPropertiesKeys[i]];
          var itemType = schemaItemRules.type,
            itemRequired = schemaItemRules.required,
            itemEnum = schemaItemRules.enum;

          // 如果该属性是必需项，但是未定义该属性，需要抛出错误
          if (itemRequired === true && !data.hasOwnProperty(schemaPropertiesKeys[i])) {
            errors.push({
              field: schemaPropertiesKeys[i],
              message: 'is required',
              schemaPath: ['properties', schemaPropertiesKeys[i]],
              type: itemType,
              value: undefined
            });
            continue;
          }

          // 如果属性存在判断类型是否符合
          if (itemType && data.hasOwnProperty(schemaPropertiesKeys[i])) {
            // 支持校验的数据类型 string number object array
            var dataItemType = _typeof(data[schemaPropertiesKeys[i]]);
            if (dataItemType === 'object') {
              dataItemType = Array.isArray(data[schemaPropertiesKeys[i]]) ? 'array' : 'object';
            }
            // 对于 undefined 类型数据，认为是无效值不校验
            if (dataItemType !== 'undefined' && !(itemType === dataItemType || itemType.indexOf(dataItemType) !== -1)) {
              errors.push({
                field: schemaPropertiesKeys[i],
                message: 'is the wrong type',
                schemaPath: ['properties', schemaPropertiesKeys[i]],
                type: itemType,
                value: data[schemaPropertiesKeys[i]]
              });
              continue;
            }
          }

          // 如果属性存在且规定取值范围判断值是否符合
          if (itemEnum && data.hasOwnProperty(schemaPropertiesKeys[i]) && itemEnum.indexOf(data[schemaPropertiesKeys[i]]) === -1) {
            errors.push({
              field: schemaPropertiesKeys[i],
              message: 'must be an enum value',
              schemaPath: ['properties', schemaPropertiesKeys[i]],
              type: itemType,
              value: data[schemaPropertiesKeys[i]]
            });
            continue;
          }
        }
      }
    }
    // 如果有不符合规则的情况，吧错误信息挂载函数上
    errors.length > 0 && (validate.errors = errors);
  };
  return validate;
}
export default function (schema, opts) {
  if (typeof schema === 'string') schema = JSON.parse(schema);
  return compile(schema, opts);
}