bookshelf-schema/lib/fields.js

// Generated by CoffeeScript 1.10.0

/*
 *
 * StringField 'username', minLength: 3, maxLength: 10
 * StringField 'username', validations: [{rule: 'minLength:3', message: 'Invalid username'}]
 *
 */
var BooleanField, DateField, DateTimeField, EmailField, EncryptedString, EncryptedStringField, Field, FloatField, IntField, JSONField, NumberField, StringField,
  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  hasProp = {}.hasOwnProperty,
  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

Field = (function() {
  function Field(name, options) {
    if (options == null) {
      options = {};
    }
    if (!(this instanceof Field)) {
      return new Field(name);
    }
    this.name = name;
    this.options = options;
  }

  Field.prototype.pluginOption = function(name, defaultVal) {
    if (name in this.model.__bookshelf_schema_options) {
      return this.model.__bookshelf_schema_options[name];
    } else {
      return defaultVal;
    }
  };

  Field.prototype.option = function(name, pluginOptionName, defaultVal) {
    var value;
    if (arguments.length === 2) {
      defaultVal = pluginOptionName;
      pluginOptionName = name;
    }
    value = this.options[name];
    if (value == null) {
      value = this.pluginOption(pluginOptionName, defaultVal);
    }
    return value;
  };

  Field.prototype.contributeToSchema = function(schema) {
    return schema.push(this);
  };

  Field.prototype.contributeToModel = function(cls) {
    var base;
    this.model = cls;
    if ((base = this.model).__bookshelf_schema == null) {
      base.__bookshelf_schema = {
        validations: {},
        parsers: [],
        formatters: []
      };
    }
    if (this.option('createProperty', 'createProperties', true)) {
      this._createProperty(cls);
    }
    if (this.option('validation', true)) {
      this._appendValidations(cls);
    }
    this._appendFormatter();
    return this._appendParser();
  };

  Field.prototype.validations = function() {
    var result;
    result = this.options.validations ? this.options.validations.slice(0) : [];
    this.acceptsRule(result, ['required', 'accepted', 'exists']);
    return result;
  };

  Field.prototype.modelValidations = function() {};

  Field.prototype.createGetter = function() {
    var name;
    name = this.name;
    return function() {
      return this.get(name);
    };
  };

  Field.prototype.createSetter = function() {
    var name;
    name = this.name;
    return function(value) {
      return this.set(name, value);
    };
  };

  Field.prototype.acceptsRule = function(validations, names, rule) {
    var i, len, name;
    if (!(names instanceof Array)) {
      names = [names];
    }
    if (rule == null) {
      rule = names[0];
    }
    for (i = 0, len = names.length; i < len; i++) {
      name = names[i];
      if (!(name in this.options)) {
        continue;
      }
      validations.push(this._normalizeRule(rule, this.options[name]));
      return;
    }
  };

  Field.prototype._createProperty = function(cls) {
    var getter, setter, spec;
    if (this.name === 'id' || this.name in cls.prototype) {
      return;
    }
    spec = {};
    getter = this.createGetter();
    setter = this.createSetter();
    if (getter) {
      spec.get = getter;
    }
    if (setter) {
      spec.set = setter;
    }
    return Object.defineProperty(cls.prototype, this.name, spec);
  };

  Field.prototype._appendValidations = function(model) {
    var meta, modelValidations, validations;
    meta = model.__bookshelf_schema;
    validations = this.validations();
    if (validations && validations.length > 0) {
      if (this.name in meta.validations) {
        if (!(meta.validations[this.name] instanceof Array)) {
          meta.validations[this.name] = [meta.validations[this.name]];
        }
      } else {
        meta.validations[this.name] = [];
      }
      meta.validations[this.name].push.apply(meta.validations[this.name], validations);
    }
    modelValidations = this.modelValidations();
    if (modelValidations && modelValidations.length > 0) {
      if (meta.modelValidations == null) {
        meta.modelValidations = [];
      }
      return meta.modelValidations.push.apply(meta.modelValidations, modelValidations);
    }
  };

  Field.prototype._normalizeRule = function(rule, value) {
    var k, result, v;
    return this._withMessage((function() {
      switch (false) {
        case !(typeof value === 'object' && !(value instanceof Array)):
          result = {
            rule: rule
          };
          for (k in value) {
            v = value[k];
            result[k] = v;
          }
          if ('value' in result) {
            if (typeof rule === 'string') {
              result.rule += ':' + result.value;
            } else {
              result.params = result.value;
            }
            delete result.value;
          }
          result.params || (result.params = []);
          return result;
        case typeof value !== 'boolean':
          return rule;
        case typeof rule !== 'string':
          return rule + ":" + value;
        default:
          return this._normalizeRule(rule, {
            value: value
          });
      }
    }).call(this));
  };

  Field.prototype._withMessage = function(rule) {
    if (!((this.options.message != null) || (this.options.label != null))) {
      return rule;
    }
    if (typeof rule !== 'object') {
      rule = {
        rule: rule
      };
    }
    if (this.options.message != null) {
      if (rule.message == null) {
        rule.message = this.options.message;
      }
    }
    if (this.options.label != null) {
      if (rule.label == null) {
        rule.label = this.options.label;
      }
    }
    return rule;
  };

  Field.prototype._appendFormatter = function() {
    if (typeof this.format === 'function') {
      return this.model.__bookshelf_schema.formatters.push(this.format.bind(this));
    }
  };

  Field.prototype._appendParser = function() {
    if (typeof this.parse === 'function') {
      return this.model.__bookshelf_schema.parsers.push(this.parse.bind(this));
    }
  };

  return Field;

})();

StringField = (function(superClass) {
  extend(StringField, superClass);

  function StringField(name, options) {
    if (!(this instanceof StringField)) {
      return new StringField(name, options);
    }
    StringField.__super__.constructor.call(this, name, options);
  }

  StringField.prototype.validations = function() {
    var result;
    result = StringField.__super__.validations.apply(this, arguments);
    this.acceptsRule(result, ['minLength', 'min_length']);
    this.acceptsRule(result, ['maxLength', 'max_length']);
    return result;
  };

  return StringField;

})(Field);

EmailField = (function(superClass) {
  extend(EmailField, superClass);

  function EmailField(name, options) {
    if (!(this instanceof EmailField)) {
      return new EmailField(name, options);
    }
    EmailField.__super__.constructor.call(this, name, options);
  }

  EmailField.prototype.validations = function() {
    var result;
    result = EmailField.__super__.validations.apply(this, arguments);
    result.push(this._withMessage('email'));
    return result;
  };

  return EmailField;

})(StringField);

EncryptedString = (function() {
  function EncryptedString(encrypted, plain1, options1) {
    var base;
    this.encrypted = encrypted;
    this.plain = plain1;
    this.options = options1 != null ? options1 : {};
    if ((base = this.options).saltLength == null) {
      base.saltLength = 16;
    }
  }

  EncryptedString.prototype.encrypt = function() {
    return this._genSalt(this.options.saltLength).then((function(_this) {
      return function(salt) {
        return _this._genHash(_this.plain, salt).then(function(hash) {
          return _this.encrypted = salt.toString('base64') + '$' + hash.toString('base64');
        });
      };
    })(this));
  };

  EncryptedString.prototype.verify = function(value) {
    var checked, salt;
    checked = this.encrypted.split('$');
    salt = new Buffer(checked[0], 'base64');
    return this._genHash(value, salt).then(function(hash) {
      return hash.toString('base64') === checked[1];
    });
  };

  EncryptedString.prototype._genSalt = function(length) {
    var crypto;
    if (this.options.saltAlgorithm) {
      return this.options.saltAlgorithm(length, callback);
    } else {
      crypto = require('crypto');
      return new Promise(function(resolve, reject) {
        return crypto.randomBytes(length, function(err, salt) {
          if (err) {
            return reject(err);
          } else {
            return resolve(salt);
          }
        });
      });
    }
  };

  EncryptedString.prototype._genHash = function(plain, salt) {
    var crypto, digest, iterations, keylen;
    iterations = this.options.iterations || 1000;
    keylen = this.options.length || 512;
    if (typeof this.options.algorithm === 'function') {
      return this.options.algorithm(plain, salt, iterations, keylen);
    } else {
      crypto = require('crypto');
      digest = typeof this.options.algorithm === 'string' ? this.options.algorithm : 'sha256';
      return new Promise(function(resolve, reject) {
        return crypto.pbkdf2(plain, salt, iterations, keylen, digest, function(err, hash) {
          if (err) {
            return reject(err);
          } else {
            return resolve(hash);
          }
        });
      });
    }
  };

  return EncryptedString;

})();

EncryptedStringField = (function(superClass) {
  extend(EncryptedStringField, superClass);

  function EncryptedStringField(name, options) {
    if (options == null) {
      options = {};
    }
    this._onSaving = bind(this._onSaving, this);
    if (!(this instanceof EncryptedStringField)) {
      return new EncryptedStringField(name, options);
    }
    EncryptedStringField.__super__.constructor.call(this, name, options);
  }

  EncryptedStringField.prototype.validations = function() {
    var result;
    result = EncryptedStringField.__super__.validations.call(this);
    this.acceptsRule(result, ['minLength', 'min_length'], this._validateMinLenghth);
    this.acceptsRule(result, ['maxLength', 'max_length'], this._validateMaxLenghth);
    return result;
  };

  EncryptedStringField.prototype.initialize = function(instance) {
    return instance.on('saving', this._onSaving);
  };

  EncryptedStringField.prototype.parse = function(attrs, options) {
    if (attrs[this.name] == null) {
      return attrs;
    }
    attrs[this.name] = new EncryptedString(attrs[this.name], null, this.options);
    return attrs;
  };

  EncryptedStringField.prototype.format = function(attrs, options) {
    var me;
    me = attrs[this.name];
    if (me == null) {
      return attrs;
    }
    if (!(me instanceof EncryptedString && me.encrypted)) {
      throw new Error("Field @name should be encryted first");
    }
    attrs[this.name] = me.encrypted;
    return attrs;
  };

  EncryptedStringField.prototype._validateMinLenghth = function(value, minLength) {
    if (value instanceof EncryptedString && (value.plain == null)) {
      return;
    }
    value = value instanceof EncryptedString ? value.plain : value;
    return value.length >= minLength;
  };

  EncryptedStringField.prototype._validateMaxLenghth = function(value, maxLength) {
    if (value instanceof EncryptedString && (value.plain == null)) {
      return;
    }
    value = value instanceof EncryptedString ? value.plain : value;
    return value.length <= maxLength;
  };

  EncryptedStringField.prototype._onSaving = function(instance, attrs, options) {
    var me;
    me = attrs[this.name] || instance.attributes[this.name];
    if (me == null) {
      return;
    }
    if (me instanceof EncryptedString && !me.plain) {
      return;
    }
    if (!(me instanceof EncryptedString)) {
      me = attrs[this.name] = instance.attributes[this.name] = new EncryptedString(null, me, this.options);
    }
    return me.encrypt();
  };

  return EncryptedStringField;

})(Field);

NumberField = (function(superClass) {
  extend(NumberField, superClass);

  function NumberField(name, options) {
    if (!(this instanceof NumberField)) {
      return new NumberField(name, options);
    }
    NumberField.__super__.constructor.call(this, name, options);
  }

  NumberField.prototype.validations = function() {
    var result;
    result = NumberField.__super__.validations.apply(this, arguments);
    this.acceptsRule(result, ['greaterThan', 'greater_than', 'gt']);
    this.acceptsRule(result, ['greaterThanEqualTo', 'greater_than_equal_to', 'gte', 'min']);
    this.acceptsRule(result, ['lessThan', 'less_than', 'lt']);
    this.acceptsRule(result, ['lessThanEqualTo', 'less_than_equal_to', 'lte', 'max']);
    return result;
  };

  return NumberField;

})(Field);

IntField = (function(superClass) {
  extend(IntField, superClass);

  function IntField(name, options) {
    if (!(this instanceof IntField)) {
      return new IntField(name, options);
    }
    IntField.__super__.constructor.call(this, name, options);
  }

  IntField.prototype.validations = function() {
    var result;
    result = IntField.__super__.validations.apply(this, arguments);
    this.acceptsRule(result, ['naturalNonZero', 'positive']);
    this.acceptsRule(result, 'natural');
    result.unshift(this._withMessage('integer'));
    return result;
  };

  IntField.prototype.parse = function(attrs) {
    if (attrs[this.name] != null) {
      return attrs[this.name] = parseInt(attrs[this.name]);
    }
  };

  return IntField;

})(NumberField);

FloatField = (function(superClass) {
  extend(FloatField, superClass);

  function FloatField(name, options) {
    if (!(this instanceof FloatField)) {
      return new FloatField(name, options);
    }
    FloatField.__super__.constructor.call(this, name, options);
  }

  FloatField.prototype.validations = function() {
    var result;
    result = FloatField.__super__.validations.apply(this, arguments);
    result.unshift(this._withMessage('numeric'));
    return result;
  };

  FloatField.prototype.parse = function(attrs) {
    if (attrs[this.name] != null) {
      return attrs[this.name] = parseFloat(attrs[this.name]);
    }
  };

  return FloatField;

})(NumberField);

BooleanField = (function(superClass) {
  extend(BooleanField, superClass);

  function BooleanField(name, options) {
    if (!(this instanceof BooleanField)) {
      return new BooleanField(name, options);
    }
    BooleanField.__super__.constructor.call(this, name, options);
  }

  BooleanField.prototype.parse = function(attrs) {
    if (this.name in attrs) {
      return attrs[this.name] = !!attrs[this.name];
    }
  };

  BooleanField.prototype.format = function(attrs) {
    if (this.name in attrs) {
      return attrs[this.name] = !!attrs[this.name];
    }
  };

  return BooleanField;

})(Field);

DateTimeField = (function(superClass) {
  extend(DateTimeField, superClass);

  function DateTimeField(name, options) {
    if (!(this instanceof DateTimeField)) {
      return new DateTimeField(name, options);
    }
    DateTimeField.__super__.constructor.call(this, name, options);
  }

  DateTimeField.prototype.validations = function() {
    var result;
    result = DateTimeField.__super__.validations.apply(this, arguments);
    result.push(this._withMessage(this._validateDatetime));
    return result;
  };

  DateTimeField.prototype.parse = function(attrs) {
    if (attrs[this.name] != null) {
      return attrs[this.name] = new Date(attrs[this.name]);
    }
  };

  DateTimeField.prototype.format = function(attrs) {
    if ((attrs[this.name] != null) && !(attrs[this.name] instanceof Date)) {
      return attrs[this.name] = new Date(attrs[this.name]);
    }
  };

  DateTimeField.prototype._validateDatetime = function(value) {
    if (value instanceof Date) {
      return true;
    }
    if (typeof value === 'string' && !isNaN(Date.parse(value))) {
      return true;
    }
    return false;
  };

  return DateTimeField;

})(Field);

DateField = (function(superClass) {
  extend(DateField, superClass);

  function DateField(name, options) {
    if (!(this instanceof DateField)) {
      return new DateField(name, options);
    }
    DateField.__super__.constructor.call(this, name, options);
  }

  DateField.prototype.parse = function(attrs) {
    var d;
    if (attrs[this.name] != null) {
      d = new Date(attrs[this.name]);
      return attrs[this.name] = new Date(d.getFullYear(), d.getMonth(), d.getDate());
    }
  };

  DateField.prototype.format = function(attrs) {
    var d;
    if (attrs[this.name] != null) {
      d = !(attrs[this.name] instanceof Date) ? new Date(attrs[this.name]) : attrs[this.name];
      return attrs[this.name] = new Date(d.getFullYear(), d.getMonth(), d.getDate());
    }
  };

  return DateField;

})(DateTimeField);

JSONField = (function(superClass) {
  extend(JSONField, superClass);

  function JSONField(name, options) {
    if (!(this instanceof JSONField)) {
      return new JSONField(name, options);
    }
    JSONField.__super__.constructor.call(this, name, options);
  }

  JSONField.prototype.validations = function() {
    var result;
    result = JSONField.__super__.validations.apply(this, arguments);
    result.push(this._withMessage(this._validateJSON));
    return result;
  };

  JSONField.prototype.format = function(attrs) {
    if (!(attrs[this.name] && typeof attrs[this.name] === 'object')) {
      return;
    }
    return attrs[this.name] = JSON.stringify(attrs[this.name]);
  };

  JSONField.prototype.parse = function(attrs) {
    if (!(attrs[this.name] && typeof attrs[this.name] === 'string')) {
      return;
    }
    return attrs[this.name] = JSON.parse(attrs[this.name]);
  };

  JSONField.prototype._validateJSON = function(value) {
    if (typeof value === 'object') {
      return true;
    }
    if (typeof value !== 'string') {
      return false;
    }
    JSON.parse(value);
    return true;
  };

  return JSONField;

})(Field);

module.exports = {
  Field: Field,
  StringField: StringField,
  EmailField: EmailField,
  EncryptedStringField: EncryptedStringField,
  NumberField: NumberField,
  IntField: IntField,
  FloatField: FloatField,
  BooleanField: BooleanField,
  DateTimeField: DateTimeField,
  DateField: DateField,
  JSONField: JSONField
};