alinex-validator/dist/type/Any.js

'use strict';

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

var _Schema = require('./Schema');

var _Schema2 = _interopRequireDefault(_Schema);

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 AnySchema extends _Schema2.default {
  constructor(base) {
    super(base);

    let raw = this._rules.descriptor.pop();
    this._rules.descriptor.push(this._allowDescriptor, raw);
    raw = this._rules.validator.pop();
    this._rules.validator.push(this._allowValidator, raw);
  }

  allow(...values) {
    const set = this._setting;
    const value = values.reduce((acc, val) => acc.concat(val), []);
    if (value.length === 1 && value[0] === undefined) delete set.allow;else if (value.length === 1 && value[0] instanceof _Reference2.default) set.allow = value[0];else {
      set.allow = new Set();
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          const e = _step.value;

          if (value === undefined) set.required = false;
          set.allow.add(e);
          if (set.deny) set.deny.delete(e);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
    return this;
  }
  deny(...values) {
    const set = this._setting;
    const value = values.reduce((acc, val) => acc.concat(val), []);
    if (value.length === 1 && value[0] === undefined) delete set.deny;else if (value.length === 1 && value[0] instanceof _Reference2.default) set.deny = value[0];else {
      set.deny = new Set();
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

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

          if (value === undefined) set.required = true;
          set.deny.add(e);
          if (set.allow) set.allow.delete(e);
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
    return this;
  }

  valid(value) {
    const set = this._setting;
    if (value === undefined) set.required = false;else if (set.allow instanceof _Reference2.default) {
      throw new Error('No single value if complete allow() list is set as reference.');
    } else {
      if (!set.allow) set.allow = new Set();
      set.allow.add(value);
      if (set.deny && !(set.deny instanceof _Reference2.default)) set.deny.delete(value);
    }
    return this;
  }
  invalid(value) {
    const set = this._setting;
    if (value === undefined) set.required = true;else if (set.deny instanceof _Reference2.default) {
      throw new Error('No single value if complete deny() list is set as reference.');
    } else {
      if (!set.deny) set.deny = new Set();
      set.deny.add(value);
      if (set.allow && !(set.allow instanceof _Reference2.default)) set.allow.delete(value);
    }
    return this;
  }

  _allowDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.deny instanceof _Reference2.default) {
      msg += `The values within ${set.deny.description} are not allowed. `;
    } else if (set.deny && set.deny.size) {
      msg += `The values ${Array.from(set.deny).join(', ').replace(/(.*),/, '$1 and')} \
are not allowed. `;
    }
    if (set.allow instanceof _Reference2.default) {
      msg += `Only the values within ${set.allow.description} are allowed. `;
    } else if (set.allow && set.allow.size) {
      msg += `Only the values ${Array.from(set.allow).join(', ').replace(/(.*),/, '$1 and')} \
are allowed. `;
    }
    return msg.length ? `${msg.trim()}\n` : '';
  }

  _allowValidator(data) {
    const check = this._check;
    this._checkArray('allow');
    this._checkArray('deny');

    const datastring = JSON.stringify(data.value);
    if (check.deny && check.deny.length && check.deny.filter(e => datastring === JSON.stringify(e)).length) {
      return Promise.reject(new _Error2.default(this, data, 'Element found in blacklist (denyed item).'));
    }

    if (check.allow && check.allow.length && check.allow.filter(e => datastring === JSON.stringify(e)).length === 0) {
      return Promise.reject(new _Error2.default(this, data, 'Element not in whitelist (allowed item).'));
    }

    return Promise.resolve();
  }
}

exports.default = AnySchema;