swagger-decorator/dist/entity/factory.js

Decorator for Koa2 and koa-router, Auto-Generate Swagger Docs

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _keys = require("babel-runtime/core-js/object/keys");

var _keys2 = _interopRequireDefault(_keys);

var _getIterator2 = require("babel-runtime/core-js/get-iterator");

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _defineProperty2 = require("babel-runtime/helpers/defineProperty");

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _defineProperties = require("babel-runtime/core-js/object/define-properties");

var _defineProperties2 = _interopRequireDefault(_defineProperties);

exports.instantiate = instantiate;
exports.extractRulesFromClass = extractRulesFromClass;

var _singleton = require("../internal/singleton");

var _type = require("./type");

var _validator = require("../lib/declarative-validator/src/core/validator");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var debug = require("debug")("factory");

/**
 * Description 从实体类中生成对象，并且进行数据校验；注意，这里会进行递归生成，即对实体类对象同样进行生成
 * @param EntityClass 实体类
 * @param data 数据对象
 * @param ignore 是否忽略校验
 * @param strict 是否忽略非预定义类属性
 * @throws 当校验失败，会抛出异常
 */

function instantiate(EntityClass, data) {
  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
      _ref$ignore = _ref.ignore,
      ignore = _ref$ignore === undefined ? false : _ref$ignore,
      _ref$strict = _ref.strict,
      strict = _ref$strict === undefined ? true : _ref$strict;

  var innerObject = _singleton.innerEntityObject[EntityClass.name];

  debug(innerObject);

  var innerObjectProperties = innerObject.properties;

  var validation = {
    isPass: true
  };

  // 判断是否需要忽略，不忽略则进行校验
  if (!ignore) {
    validation = (0, _validator.validate)(data, extractRulesFromClass(EntityClass));
  }

  if (!validation.isPass) {
    // 如果校验失败，则抛出异常
    var error = new Error("validate fail!");

    error.validation = validation;

    debug(validation);

    throw error;
  } else {
    // 这里将数据作为初始化参数传入，以保证部分实体类实现时会传入数据
    var instance = new EntityClass(data);

    // 遍历数据进行内部属性初始化

    var _loop = function _loop(property) {
      // 首先判断该属性是否在预定义的属性内
      if (!innerObjectProperties.hasOwnProperty(property)) {
        if (strict) {
          // 严格模式下忽略该数据
          return "continue";
        } else {
          // 否则直接当做新数据挂载上去
          instance[property] = data[property];
          return "continue";
        }
      }

      var type = innerObjectProperties[property].type;

      // 判断是否为原始类型

      if ((0, _type.isPrimitive)(type)) {
        try {
          instance[property] = data[property];
        } catch (e) {
          (0, _defineProperties2.default)(instance, (0, _defineProperty3.default)({}, property, {
            writable: true,
            enumerable: true,
            value: data[property]
          }));
        }
      } else {
        // 判断是否为数组
        if (type === "array" || Array.isArray(type)) {
          // 如果为数组则返回数组
          instance[property] = data[property].map(function (data) {
            return instantiate(type[0], data[property], {
              ignore: ignore,
              strict: strict
            });
          });
        } else {
          instance[property] = instantiate(type, data[property], {
            ignore: ignore,
            strict: strict
          });
        }
      }
    };

    for (var property in data) {
      var _ret = _loop(property);

      if (_ret === "continue") continue;
    }

    return instance;
  }
}

/**
 * Description 从
 * @param EntityClass
 */
function extractRulesFromClass(EntityClass) {
  var innerObject = _singleton.innerEntityObject[EntityClass.name];

  var rules = {};

  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = (0, _getIterator3.default)((0, _keys2.default)(innerObject.properties)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var propertyName = _step.value;

      var rule = undefined;

      var property = innerObject.properties[propertyName];

      var requiredCondition = innerObject.required && innerObject.required.includes(propertyName);

      // 首先判断是否存在 pattern，如果存在则提取
      if (property.pattern) {
        rule = property.pattern;

        if (requiredCondition) {
          rule = "required|" + rule;
        }
      } else {
        // 判断是否为必须值
        if (requiredCondition) {
          rule = "required";
        }
      }

      // 仅当规则不为空，才加进来
      rule && (rules[propertyName] = rule);
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return rules;
}