youbase/lib/document.js

var Collection, Definition, Document, Envelope, HDKey, bs, crypto, defer, ecc, exports, tv4, _;

_ = require('lodash');

bs = require('bs58check');

ecc = require('ecc-tools');

tv4 = require('tv4');

defer = require('when');

crypto = require('crypto');

HDKey = require('hdkey');

Envelope = require('ecc-envelope');

Collection = require('./collection');

Definition = require('./definition');

Document = (function() {
  function Document(custodian, key) {
    var _ref, _ref1, _ref2;
    this.custodian = custodian;
    if (!(this instanceof Document)) {
      return new Document(this.custodian, key);
    }
    if (typeof key === 'string') {
      key = bs.decode(key);
    }
    this.extended = false;
    if (key.length === 78) {
      this.extended = true;
      this.hdkey = HDKey.fromExtendedKey(bs.encode(key));
      this.privateKey = this.hdkey.privateKey;
      this.publicKey = this.hdkey.publicKey;
      this.children = new Collection(this.custodian, Document, (_ref = this.hdkey.privateExtendedKey) != null ? _ref : this.hdkey.publicExtendedKey);
    } else if (key.length === 33) {
      this.publicKey = key;
    } else if (key.length === 32) {
      this.privateKey = key;
      this.publicKey = ecc.publicKey(this.privateKey, true);
    }
    if (this.publicKey) {
      this.pub = bs.encode(this.publicKey);
    }
    if (this.privateKey) {
      this.prv = bs.encode(this.privateKey);
    }
    this.xpub = (_ref1 = this.hdkey) != null ? _ref1.publicExtendedKey : void 0;
    this.xprv = (_ref2 = this.hdkey) != null ? _ref2.privateExtendedKey : void 0;
    this.readonly = this.privateKey == null;
    this._headers = {
      from: bs.encode(this.publicKey)
    };
    this._links = {};
    this.fetch()["else"](false);
  }

  Document.prototype.fetch = function() {
    return this._fetch = this.custodian.document.get(this.publicKey).then((function(_this) {
      return function(envelope) {
        if (!envelope) {
          return false;
        }
        envelope = Envelope({
          decode: envelope
        });
        return envelope.open().then(function(envelope) {
          _this._meta = envelope.data.meta;
          _this._links = envelope.data.links;
          _this._headers = envelope.data.headers;
          return envelope;
        });
      };
    })(this));
  };

  Document.prototype.link = function(key, data) {
    if (data != null) {
      return this.custodian.data.put(data).then((function(_this) {
        return function(hash) {
          return _this._links[key] = bs.encode(new Buffer(hash));
        };
      })(this));
    } else {
      return this.custodian.data.get(this._links[key]);
    }
  };

  Document.prototype.definition = function(definition) {
    if (definition != null) {
      if (this.readonly) {
        return defer(false);
      }
      definition = Definition(this.custodian, definition);
      return definition.save().then((function(_this) {
        return function(hash) {
          return _this._links.definition = bs.encode(new Buffer(hash));
        };
      })(this)).then((function(_this) {
        return function() {
          return definition.children();
        };
      })(this)).then((function(_this) {
        return function(children) {
          return _this.children._definitions = children;
        };
      })(this)).then((function(_this) {
        return function() {
          return _this._links.definition;
        };
      })(this));
    } else {
      return defer(Definition(this.custodian, this._links.definition));
    }
  };

  Document.prototype.data = function(data, alg) {
    if (alg == null) {
      alg = 'aes';
    }
    if (data != null) {
      return defer(data).then((function(_this) {
        return function(data) {
          if (_this.readonly) {
            return false;
          }
          return _this.encrypt(data, alg);
        };
      })(this));
    } else {
      return this.decrypt();
    }
  };

  Document.prototype.encrypt = function(data, alg) {
    if (alg == null) {
      alg = 'aes';
    }
    if (this.readonly) {
      return defer(false);
    }
    return this.definition().then(function(definition) {
      return definition.get('permissions');
    }).then((function(_this) {
      return function(permissions) {
        var iv, key;
        if (permissions === 'public') {
          return _this.link('data', data);
        } else if (permissions === 'hardened' || permissions === 'private') {
          if (!_this.extended) {
            return defer(false);
          }
          iv = crypto.randomBytes(16);
          if (permissions === 'hardened') {
            key = ecc.sha256(_this.xpub);
          }
          if (permissions === 'private') {
            key = ecc.sha256(_this.prv);
          }
          return ecc.cipher(data, key, iv, 'aes').then(function(ciphertext) {
            iv = bs.encode(iv);
            ciphertext = bs.encode(ciphertext);
            return _this.link('data', {
              iv: iv,
              alg: alg,
              ciphertext: ciphertext
            });
          });
        }
      };
    })(this));
  };

  Document.prototype.decrypt = function() {
    return this.definition().then(function(definition) {
      return definition.get('permissions');
    }).then((function(_this) {
      return function(permissions) {
        return _this.link('data').then(function(cipher) {
          var ciphertext, iv, key;
          if (permissions === 'public') {
            return cipher;
          }
          if (permissions === 'hardened') {
            key = ecc.sha256(_this.xpub);
          }
          if (permissions === 'private') {
            key = ecc.sha256(_this.prv);
          }
          ciphertext = bs.decode(cipher.ciphertext);
          iv = bs.decode(cipher.iv);
          return ecc.decipher(ciphertext, key, iv, cipher.alg);
        });
      };
    })(this));
  };

  Document.prototype.validate = function() {
    return this.definition().then(function(definition) {
      return definition.get('schema');
    }).then((function(_this) {
      return function(schema) {
        return _this.data().then(function(data) {
          var validation;
          if (data == null) {
            defer.reject(Error("No data"));
          }
          validation = tv4.validateMultiple(data, schema, false, true);
          _this.errors = validation.errors;
          if (validation.valid) {
            return data;
          } else {
            return defer.reject(Error("Data does not match schema: " + _this.errors + " s" + (JSON.stringify(schema)) + " d" + (JSON.stringify(data))));
          }
        });
      };
    })(this));
  };

  Document.prototype.meta = function() {
    return this.definition().then(function(definition) {
      return definition.get('meta');
    }).then((function(_this) {
      return function(meta) {
        return _this.data().then(function(data) {
          return _this._meta = _(meta).mapValues(function(path) {
            return _.get(data, path);
          }).omitBy(_.isUndefined).value();
        });
      };
    })(this));
  };

  Document.prototype.summary = function() {
    return this.meta().then((function(_this) {
      return function(meta) {
        return {
          meta: meta,
          document: _this
        };
      };
    })(this));
  };

  Document.prototype.details = function() {
    return this._fetch.then((function(_this) {
      return function() {
        return _this.data();
      };
    })(this)).then((function(_this) {
      return function(data) {
        return {
          data: data,
          document: _this
        };
      };
    })(this));
  };

  Document.prototype.save = function() {
    if (this.readonly) {
      return defer(false);
    }
    return this.validate().then((function(_this) {
      return function() {
        return _this.meta();
      };
    })(this)).then((function(_this) {
      return function(meta) {
        _this._envelope = Envelope({
          send: {
            meta: _this._meta,
            links: _this._links,
            headers: _this._headers
          },
          from: _this.privateKey
        });
        return _this.custodian.document.put(_this._envelope.encode());
      };
    })(this));
  };

  return Document;

})();

exports = module.exports = Document;