Source: components/bridge-store.js

  1. "use strict";
  2. var Promise = require("bluebird");
  4. // wrapper to use promises
  5. var callbackFn = function(d, err, result) {
  6.     if (err) {
  7.         d.reject(err);
  8.     }
  9.     else {
  10.         d.resolve(result);
  11.     }
  12. };
  14. /**
  15.  * Bridge store base class
  16.  * @constructor
  17.  * @param {Datastore} db
  18.  */
  19. function BridgeStore(db) {
  20.     this.db = db;
  21. }
  23. /**
  24.  * INSERT a multiple documents.
  25.  * @param {Object} objects
  26.  * @param {Deferred=} defer
  27.  * @return {Promise}
  28.  */
  29. BridgeStore.prototype.insert = function(objects, defer) {
  30.     defer = defer || new Promise.defer();
  31.     this.db.insert(objects, function(err, result) {
  32.         callbackFn(defer, err, result);
  33.     });
  34.     return defer.promise;
  35. };
  37. /**
  38.  * UPSERT a single document.
  39.  * @param {Object} query
  40.  * @param {Object} updateVals
  41.  * @param {Deferred=} defer
  42.  * @return {Promise}
  43.  */
  44. BridgeStore.prototype.upsert = function(query, updateVals, defer) {
  45.     defer = defer || new Promise.defer();
  46.     this.db.update(query, updateVals, {upsert: true}, function(err, result) {
  47.         callbackFn(defer, err, result);
  48.     });
  49.     return defer.promise;
  50. };
  52. /**
  53.  * INSERT IF NOT EXISTS a single document.
  54.  * @param {Object} query
  55.  * @param {Object} insertObj
  56.  * @return {Promise}
  57.  */
  58. BridgeStore.prototype.insertIfNotExists = function(query, insertObj) {
  59.     var self = this;
  60.     return self.selectOne(query).then(function(doc) {
  61.         if (doc) {
  62.             return Promise.resolve();
  63.         }
  64.         return self.insert(insertObj);
  65.     });
  66. };
  68. /**
  69.  * UPDATE a single document. If the document already exists, this will NOT update
  70.  * it.
  71.  * @param {Object} query
  72.  * @param {Object} updateVals
  73.  * @param {Deferred=} defer
  74.  * @return {Promise}
  75.  */
  76. BridgeStore.prototype.update = function(query, updateVals, defer) {
  77.     defer = defer || new Promise.defer();
  78.     this.db.update(query, updateVals, {upsert: false}, function(err, result) {
  79.         callbackFn(defer, err, result);
  80.     });
  81.     return defer.promise;
  82. };
  84. /**
  85.  * DELETE multiple documents.
  86.  * @param {Object} query
  87.  * @param {Deferred=} defer
  88.  * @return {Promise}
  89.  */
  90. BridgeStore.prototype.delete = function(query, defer) {
  91.     defer = defer || new Promise.defer();
  92.     this.db.remove(query, {multi: true}, function(err, result) {
  93.         callbackFn(defer, err, result);
  94.     });
  95.     return defer.promise;
  96. };
  98. /**
  99.  * SELECT a single document.
  100.  * @param {Object} query
  101.  * @param {Function} transformFn
  102.  * @param {Deferred=} defer
  103.  * @return {Promise}
  104.  */
  105. BridgeStore.prototype.selectOne = function(query, transformFn, defer) {
  106.     defer = defer || new Promise.defer();
  107.     this.db.findOne(query, function(err, doc) {
  108.         callbackFn(defer, err, transformFn ? transformFn(doc) : doc);
  109.     });
  110.     return defer.promise;
  111. };
  113. /**
  114.  * SELECT a number of documents.
  115.  * @param {Object} query
  116.  * @param {Function} transformFn
  117.  * @param {Deferred=} defer
  118.  * @return {Promise}
  119.  */
  120. BridgeStore.prototype.select = function(query, transformFn, defer) {
  121.     defer = defer || new Promise.defer();
  122.     this.db.find(query, function(err, docs) {
  123.         callbackFn(defer, err, transformFn ? transformFn(docs) : docs);
  124.     });
  125.     return defer.promise;
  126. };
  128. /**
  129.  * Set a UNIQUE key constraint on the given field.
  130.  * @param {string} fieldName The field name. Use dot notation for nested objects.
  131.  * @param {boolean} sparse Allow sparse entries (undefined won't cause a key
  132.  * violation). Default: false.
  133.  */
  134. BridgeStore.prototype.setUnique = function(fieldName, sparse) {
  135.     sparse = sparse || false;
  136.     this.db.ensureIndex({
  137.         fieldName: fieldName,
  138.         unique: true,
  139.         sparse: sparse
  140.     });
  141. };
  143. /**
  144.  * Convenience method to convert a document to something.
  145.  * @param {Function} func The function which will be called with a single document
  146.  * object. Guaranteed not to be null.
  147.  * @return {Function} A <code>transformFn</code> function to pass to the standard
  148.  * select/delete/upsert/etc methods.
  149.  */
  150. BridgeStore.prototype.convertTo = function(func) {
  151.     return function(doc) {
  152.         if (!doc) { // findOne query will return 'null' on no matches.
  153.             return null;
  154.         }
  155.         if (Array.isArray(doc)) {
  156.             return doc.map(function(d) {
  157.                 return func(d);
  158.             });
  159.         }
  160.         return func(doc);
  161.     };
  162. };
  164. module.exports = BridgeStore;