path: root/app/node_modules/okresource/index.js

var assign = require('object-assign');
var cloneDeep = require('lodash.clonedeep');
var Q = require('q');

/**
 * OKResource!
 * TODO Would be nicer to compose this with an existing resource
 * module, but haven't found a good fit. Should keep an eye on
 * 'resource' by bigcompany for an update.
 */
function OKResource(options) {
  if (!(this instanceof OKResource)) return new OKResource(options);
  options = options || {};
  if (!options.type)
    throw new Error('No resource type provided to OKResource')
  if (!options.schema)
    throw new Error('No schema provided to OKResource');
  if (!options.db)
    throw new Error('No DB provided to OKResource');

  var schema = options.schema;
  var spec = schema.spec;

  var type = options.type;
  this._db = options.db;
  this._schema = schema;

  // Define properties which are part of the API

  Object.defineProperty(this, 'spec', {
    get: function() {
      return schema.spec;
    },
    enumerable: true
  });

  Object.defineProperty(this, 'type', {
    value: type,
    writable: false,
    enumerable: true
  });

  // Whether this resource represents a specific data point
  // or a whole class of data
  Object.defineProperty(this, 'bound', {
    value: false,
    writable: false,
    enumerable: true
  });
}

/**
 * Throws an error if data does not conform to schema
 */
OKResource.prototype.assertValid = function(data) {
  this._schema.assertValid(data);
};

OKResource.prototype.all = function() {
  return this._db.all(this.type);
};

OKResource.prototype.getID = function(data) {
  data = data || {};
  return data[this._schema.idField];
};

OKResource.prototype.create = function(data) {
  var type = this.type;
  var db = this._db;
  return Q.promise(function(resolve, reject) {
    if (!data) {
      reject(new Error('No data provided'));
    } else {
      db.insert(type, data).then(resolve).fail(reject);
    }
  });
};

OKResource.prototype.destroy = function(id) {
  var db = this._db;
  var type = this.type;
  return Q.promise(function(resolve, reject) {
    if (!id) {
      reject(new Error('No ID provided'));
    } else {
      db.remove(type, id).then(resolve).fail(reject);
    }
  });
};

OKResource.prototype.find = function(query) {
  query = query || {};
  var db = this._db;
  var type = this.type;
  return Q.promise(function(resolve, reject) {
    if (!query) {
      throw new Error('No query provided');
    } else {
      db.find(type, query).then(resolve).fail(reject);
    }
  });
};

OKResource.prototype.get = function(id) {
  var db = this._db;
  var type = this.type;
  return Q.promise(function(resolve, reject) {
    if (!id) {
      throw new Error('No ID provided');
    } else {
      db.get(type, id).then(resolve).fail(reject);
    }
  });
};

OKResource.prototype.update = function(id, data) {
  var db = this._db;
  var type = this.type;
  return Q.promise(function(resolve, reject) {
    if (!id) {
      reject(new Error('No resource ID provided'));
    } else if (!data) {
      reject(new Error('No data provided'));
    }else {
      db.update(type, id, data).then(resolve).fail(reject);;
    }
  });
};

/**
 * Update all resources with the given ids with the given data
 */
OKResource.prototype.updateBatch = function(ids, datas) {
  // var type = this.type;
  // var db = this._db;
  // var idField = this.idField;
  // return Q.promise(function(resolve, reject) {
  //   if (!ids || !ids.length || !datas || !datas.length ||
  //       ids.length !== datas.length) {
  //     reject(new Error('Bad input'));
  //   } else {
  //     var queries = ids.map(function(id, i) {
  //       var query = {};
  //       query[idField] = datas[i][idField];
  //       return query;
  //     });
  //     db.putAll(type, queries, datas).then(resolve).fail(reject);
  //   }
  // });
};

OKResource.prototype.updateOrCreate = function(id, data) {
  data = data || {};
  var type = this.type;
  var db = this._db;
  return Q.promise(function(resolve, reject) {
    if (!id) {
      reject(new Error('No ID provided'));
    } else {
      db.get(type, id).then(function(persisted) {
        if (persisted) {
          db.update(type, id, data).then(resolve).fail(reject);
        } else {
          db.insert(type, data).then(resolve).fail(reject);
        }
      }).fail(reject);
    }
  });
};

/**
 * Create special resource which is bound to particular data point
 * and has custom validation and query properties.
 */
OKResource.prototype.instance = function(options) {
  return new OKResourceInstance(this, {
    static: options.static
  });
};

function OKResourceInstance(resource, options) {
  if (!(this instanceof OKResourceInstance)) return new OKResourceInstance(options);
  // Only support static data instances for now
  if (!options.static)
    throw new Error(
      'Cannot create OKResourceInstance without static data');

  // Resources with static data are a special case. They exist
  // conceptually at all times since they are derived from app
  // configuration, but may not actually be present
  // in the database and need custom logic to handle this.
  var staticData = cloneDeep(options.static);
  var id = resource.getID(staticData);
  if (!id)
    throw new Error(
        'Cannot create static OKResourceInstance without an ID field');

  this.getID = function() {
    return id;
  };

  /**
   * Ensure that static data is provided on get
   */
  this.get = function() {
    return Q.promise(function(resolve, reject) {
      resource.get(id).then(function(data) {
        // Note the assign call. Don't expose private references!
        if (data) {
          resolve(assign(data, cloneDeep(staticData)));
        } else {
          resolve(cloneDeep(staticData));
        }
      }).fail(reject);
    });
  };

  this.update = function(id, data) {
    return Q.promise(function(resolve, reject) {
      var valid = Object.keys(staticData).every(function(prop) {
        return staticData[prop] === data[prop];
      });
      if (!valid) {
        reject(new Error('Cannot update resource\'s static data'));
      } else {
        // When updating static resources, we create them if
        // they don't actually exist in the DB
        resource.updateOrCreate(id, data).then(resolve).fail(reject);
      }
    });
  };

  this.updateOrCreate = function(id, data) {
    return Q.promise(function(resolve, reject) {
      reject(new Error('Cannot updateOrCreate static resource'));
    });
  };

  this.destroy = function(id) {
    return Q.promise(function(resolve, reject) {
      reject(new Error('Cannot destroy static resource'));
    });
  };

  this.all = function(id) {
    return Q.promise(function(resolve, reject) {
      reject(new Error('Cannot get all for static resource'));
    });
  };

  this.create = function(id) {
    return Q.promise(function(resolve, reject) {
      reject(new Error('Cannot create static resource'));
    });
  };

  this.find = function(id) {
    return Q.promise(function(resolve, reject) {
      reject(new Error('Cannot perform find on static resource'));
    });
  };

  this.assertValid = function(data) {
    data = data || {};
    Object.keys(staticData).forEach(function(prop) {
      if (staticData[prop] !== data[prop]) {
        // Validation error is in mschema error format
        throw [{
          property: prop,
          constraint: 'static',
          expected: staticData[prop],
          actual: data[prop],
          message: 'Data does not match static data'
        }];
      }
    });
    resource.assertValid(data);
  };

  Object.defineProperty(this, 'parent', {
    value: resource,
    writable: false,
    enumerable: true
  });

  Object.defineProperty(this, 'spec', {
    get: function() {
      return resource.spec
    },
    enumerable: true
  });

  Object.defineProperty(this, 'type', {
    value: resource.type,
    writable: false,
    enumerable: true
  });

  Object.defineProperty(this, 'bound', {
    value: true,
    writable: false,
    enumerable: true
  });
}

module.exports = OKResource;