alinex-validator/dist/type/Schema.js

'use strict';

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

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _Data = require('../Data');

var _Data2 = _interopRequireDefault(_Data);

var _Error = require('../Error');

var _Error2 = _interopRequireDefault(_Error);

var _Reference = require('../Reference');

var _Reference2 = _interopRequireDefault(_Reference);

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

class Schema {

  constructor(base) {
    if (base) this.base = base;
    this.debug = (0, _debug2.default)(`validator:${this.constructor.name.replace(/Schema/, '').toLowerCase()}`);
    this._title = this.constructor.name.replace(/(.)Schema/, '$1');
    this._detail = 'should be defined with';
    this._rules = {
      descriptor: [],
      check: [],
      validator: []
    };
    this._setting = {};

    this._rules.descriptor.push(this._emptyDescriptor, this._optionalDescriptor, this._rawDescriptor);
    this._rules.validator.push(this._emptyValidator, this._optionalValidator, this._rawValidator);
  }

  inspect(depth, options) {
    const newOptions = Object.assign({}, options, {
      depth: options.depth === null ? null : options.depth - 1
    });
    const base = this.base ? `base=${_util2.default.inspect(this.base)} ` : '';
    const padding = ' '.repeat(5);
    const inner = _util2.default.inspect(this._setting, newOptions).replace(/\n/g, `\n${padding}`);
    return `${options.stylize(this.constructor.name, 'class')} ${base}${inner} `;
  }

  title(title) {
    this._title = title;
    return this;
  }
  detail(detail) {
    this._detail = detail;
    return this;
  }
  schema(path) {
    let obj = this;
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = path.split(/\//)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        const key = _step.value;

        if (obj instanceof Schema) obj = obj._setting[key];else if (obj instanceof Map) obj = obj.get(key);else obj = obj[key];
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    if (!(obj instanceof Schema)) throw new Error(`No schema element under ${path} found`);
    return obj;
  }

  _setError(name, msg) {
    throw new Error(msg || `In ${this.constructor.name} you are not allowed to set
      ${name} manually`);
  }
  _setFlag(name, flag = true) {
    if (flag) this._setting[name] = flag;else delete this._setting[name];
    return this;
  }
  _setAny(name, value) {
    if (value) this._setting[name] = value;else delete this._setting[name];
    return this;
  }
  _isReference(name) {
    return this._setting[name] instanceof _Reference2.default;
  }
  _checkBoolean(name) {
    let value;
    switch (typeof this._check[name]) {
      case 'undefined':
      case 'boolean':
        break;
      case 'string':
        value = this._check[name].toLowerCase();
        if (value === undefined) this._check[name] = false;else if (Array.isArray(value)) this._check[name] = value.length > 0;else if (typeof value === 'object') this._check[name] = Object.keys(value).length > 0;else if (['yes', 1, '1', 'true', 't', '+'].includes(value)) this._check[name] = true;else if (['no', 0, '0', 'false', 'f', '', '-'].includes(value)) this._check[name] = false;
        break;
      default:
        throw new Error(`No boolean value for \`${name}\` setting given in \
${this._setting[name] && this._setting[name].description || this._setting[name]}`);
    }
  }
  _checkString(name) {
    const check = this._check;
    if (check[name] && typeof check[name] !== 'string') {
      throw new Error(`No string value for \`${name}\` setting given in \
${this._setting[name] && this._setting[name].description || this._setting[name]}`);
    }
  }
  _checkArrayString(name) {
    this._checkArray(name);
    const check = this._check;
    if (check[name]) {
      check[name].forEach(e => {
        if (typeof e !== 'string') {
          throw new Error(`No string value for \`${name}\` setting given in \
    ${this._setting[name] && this._setting[name].description || this._setting[name]}`);
        }
      });
    }
  }
  _checkNumber(name) {
    const check = this._check;
    if (check[name] && typeof check[name] !== 'number') {
      throw new Error(`No numerical value for \`${name}\` setting given in \
${this._setting[name] && this._setting[name].description || this._setting[name]}`);
    }
  }
  _checkArray(name) {
    const check = this._check;
    if (check[name]) {
      if (check[name] instanceof Set) check[name] = Array.from(check[name]);else if (!Array.isArray(check[name])) {
        if (typeof check[name] === 'object') check[name] = Object.keys(check[name]);else check[name] = [check[name]];
      }
    }
  }
  _checkObject(name) {
    const check = this._check;
    if (!check[name]) check[name] = {};else if (typeof check[name] !== 'object') {
      throw new Error(`No object for \`${name}\` setting given in \
${this._setting[name] && this._setting[name].description || this._setting[name]}`);
    }
  }
  _checkMatch(name) {
    const check = this._check;
    if (check[name] === undefined) return;
    if (check[name] instanceof RegExp) return;
    const e = check[name].toString();
    if (e.match(/^\/([^\\/]|\\.)+\/[gi]*$/)) {
      const parts = e.match(/([^\\/]|\\.)+/g);
      if (parts.length < 1 || parts.length > 2) {
        throw new Error(`Could not convert ${_util2.default.inspect(check[name])} to regular expression`);
      }
      check[name] = new RegExp(parts[0], parts[1]);
    }
    check[name] = check[name].toString();
  }
  _checkArrayMatch(name) {
    this._checkArray(name);
    const check = this._check;
    if (check[name] === undefined) return;
    check[name] = check[name].map(e => {
      if (e instanceof RegExp) return e;
      const el = e.toString();
      if (el.match(/^\/([^\\/]|\\.)+\/[gi]*$/)) {
        const parts = el.match(/([^\\/]|\\.)+/g);
        if (parts.length < 1 || parts.length > 2) {
          throw new Error(`Could not convert ${_util2.default.inspect(e)} to regular expression`);
        }
        return new RegExp(parts[0], parts[1]);
      }
      return el;
    });
  }

  stripEmpty(flag) {
    return this._setFlag('stripEmpty', flag);
  }

  _emptyDescriptor() {
    const set = this._setting;
    if (set.stripEmpty instanceof _Reference2.default) {
      return `Empty values are set to \`undefined\` depending on ${set.stripEmpty.description}.\n`;
    }
    return set.stripEmpty ? 'Empty values are set to `undefined`.\n' : '';
  }

  _emptyValidator(data) {
    const check = this._check;
    try {
      this._checkBoolean('stripEmpty');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }
    if (check.stripEmpty && (data.value === '' || data.value === null || Array.isArray(data.value) && !data.value.length || Object.keys(data.value).length === 0 && data.value.constructor === Object)) {
      data.value = undefined;
    }
    return Promise.resolve();
  }

  required(flag) {
    const set = this._setting;
    if (set.forbidden && !this._isReference('forbidden')) {
      throw new Error('This is already `forbidden` and can´t be also be `required`');
    }
    return this._setFlag('required', flag);
  }
  forbidden(flag) {
    const set = this._setting;
    if (set.required && !this._isReference('required')) {
      throw new Error('This is already `required` and can´t be also be `forbidden`');
    }
    return this._setFlag('forbidden', flag);
  }
  default(value) {
    return this._setAny('default', value);
  }

  _optionalDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.default) {
      const value = set.default instanceof _Reference2.default ? set.default.description : _util2.default.inspect(set.default);
      msg += `It will default to ${value} if not set. `;
    }
    if (set.required) {
      if (set.required instanceof _Reference2.default) {
        msg += `It is required depending on ${set.required.description}. `;
      } else msg += 'It is required and has to be set with a value. ';
    }
    if (set.forbidden) {
      if (set.forbidden instanceof _Reference2.default) {
        msg += `It is forbidden depending on ${set.forbidden.description}. `;
      } else msg += 'It is forbidden and could not contain a value. ';
    }
    return msg.replace(/ $/, '\n');
  }

  _optionalValidator(data) {
    const check = this._check;
    try {
      this._checkBoolean('required');
      this._checkBoolean('forbidden');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (data.value === undefined && check.default) data.value = check.default;

    if (check.required && data.value === undefined) {
      return Promise.reject(new _Error2.default(this, data, 'This element is mandatory!'));
    }
    if (check.forbidden && data.value !== undefined) {
      return Promise.reject(new _Error2.default(this, data, 'This element is forbidden!'));
    }
    if (data.value === undefined) return Promise.reject();
    return Promise.resolve();
  }

  raw(flag) {
    return this._setFlag('raw', flag);
  }

  _rawDescriptor() {
    const set = this._setting;
    if (set.raw instanceof _Reference2.default) {
      return `The original value is used depending on ${set.raw.description}.\n`;
    }
    return set.raw ? 'After validation the original value is used.\n' : '';
  }

  _rawValidator(data) {
    const check = this._check;
    try {
      this._checkBoolean('raw');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }
    if (check.raw) data.value = data.orig;
    return Promise.resolve();
  }

  get clone() {
    return Object.assign(Object.create(this), this);
  }

  get description() {
    let msg = '';

    if (this.base) {
      msg += `Use as base: ${_util2.default.inspect(this.base instanceof _Data2.default ? this.base.value : this.base).trim()}. `;
    }

    this._rules.descriptor.forEach(rule => {
      if (rule) msg += rule.call(this);
    });
    return msg.trim();
  }

  _validate(value, source, options) {
    if (this.debug.enabled) {
      this.debug(_util2.default.inspect(value));
      this.debug(`   ${_util2.default.inspect(this)}`);
    }
    const data = value instanceof _Data2.default ? value : new _Data2.default(value, source, options);
    if (this.base) {
      data.value = this.base instanceof _Data2.default ? this.base.value : this.base;
    }
    let p = Promise.resolve();

    if (data.value instanceof _Reference2.default) {
      p = p.then(() => data.value.raw().resolve(data)).then(res => {
        data.value = res;
        if (this.debug.enabled) this.debug(`   Use base: ${_util2.default.inspect(data)}`);
      });
    }

    const par = [];
    this._check = {};
    const set = this._setting;
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
      for (var _iterator2 = Object.keys(set)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        const key = _step2.value;

        let raw = set[key];
        if (raw instanceof Set) raw = Array.from(raw);
        if (raw instanceof _Reference2.default) {
          par.push(raw.resolve(data).then(res => {
            this._check[key] = res;
          }));
        } else if (Array.isArray(raw)) {
          this._check[key] = [];
          var _iteratorNormalCompletion3 = true;
          var _didIteratorError3 = false;
          var _iteratorError3 = undefined;

          try {
            for (var _iterator3 = raw.keys()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
              const i = _step3.value;

              const e = raw[i];
              if (e instanceof _Reference2.default) {
                this._check[key][i] = null;
                par.push(e.resolve(data).then(res => {
                  this._check[key][i] = res;
                }));
              } else if (Array.isArray(e)) {
                this._check[key][i] = [];
                var _iteratorNormalCompletion4 = true;
                var _didIteratorError4 = false;
                var _iteratorError4 = undefined;

                try {
                  for (var _iterator4 = e.keys()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                    const j = _step4.value;

                    const sub = e[j];
                    if (sub instanceof _Reference2.default) {
                      this._check[key][i][j] = null;
                      par.push(sub.resolve(data).then(res => {
                        this._check[key][i][j] = res;
                      }));
                    } else this._check[key][i][j] = sub;
                  }
                } catch (err) {
                  _didIteratorError4 = true;
                  _iteratorError4 = err;
                } finally {
                  try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                      _iterator4.return();
                    }
                  } finally {
                    if (_didIteratorError4) {
                      throw _iteratorError4;
                    }
                  }
                }
              } else this._check[key].push(e);
            }
          } catch (err) {
            _didIteratorError3 = true;
            _iteratorError3 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3.return) {
                _iterator3.return();
              }
            } finally {
              if (_didIteratorError3) {
                throw _iteratorError3;
              }
            }
          }
        } else if (raw instanceof Map) {
          this._check[key] = {};
          var _iteratorNormalCompletion5 = true;
          var _didIteratorError5 = false;
          var _iteratorError5 = undefined;

          try {
            for (var _iterator5 = raw.keys()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
              const k = _step5.value;

              const e = raw.get(k);
              if (e instanceof _Reference2.default) {
                this._check[key][k] = null;
                par.push(e.resolve(data).then(res => {
                  this._check[key][k] = res;
                }));
              } else this._check[key][k] = e;
            }
          } catch (err) {
            _didIteratorError5 = true;
            _iteratorError5 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion5 && _iterator5.return) {
                _iterator5.return();
              }
            } finally {
              if (_didIteratorError5) {
                throw _iteratorError5;
              }
            }
          }
        } else this._check[key] = raw;
      }
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2.return) {
          _iterator2.return();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }

    p = p.then(() => Promise.all(par));

    this._rules.validator.forEach(rule => {
      p = p.then(() => rule.call(this, data));
    });

    return p.then(() => {
      if (this.debug.enabled) this.debug(`=> ${_util2.default.inspect(data)}`);
      data.done(data.value);
      return data;
    }).catch(err => {
      if (this.debug.enabled) {
        if (err) this.debug(`=> ${_util2.default.inspect(err)}`);else this.debug(`=> ${_util2.default.inspect(data)}`);
      }
      return err ? Promise.reject(err) : data;
    });
  }

  validate(value, source, options) {
    return this._validate(value, source, options).then(data => data.value);
  }
}

exports.default = Schema;