Support for firestore

Author: rickerbh

README.md

@@ -294,6 +294,44 @@ Additionaly for elasticsearch6 the number of shards, number of replicas, the ref
     });
 ```
 
+## Firestore
+
+### Setup
+
+#### Library installation
+
+`yarn add @google-cloud/firestore` or `npm install --save @google-cloud/firestore`
+
+#### Options
+
+Use the `firestore` type to support Google's Firestore database, and store your KeyFile in a location accessible by your application.
+
+```javascript
+const options = {
+  repository: {
+    type: 'firestore',
+    projectId: 'YOUR_PROJECT_ID',
+    keyFilename: '/path/to/keyfile.json',
+  },
+};
+```
+
+### Find Queries
+
+Find queries in Firestore are not compatible with MongoDb syntax. The query parameter passed to `find` or `findOne` should be an array with the separate query fields as individual elements, as they will be `apply`'d and passed to the `where` function on the `Query` object.
+
+``` javascript
+    aRepo.find(['aProp', '==', 'aValue'], (err, vm) => {
+        if (err) {
+            console.log('Repo find error', err);
+            return;
+        }
+        console.log('Found', vm);
+    });
+```
+
+The queryOptions parameter is also ignored.
+
 
 # [Release notes](https://github.com/adrai/node-viewmodel/blob/master/releasenotes.md)
 
@@ -310,6 +348,7 @@ Currently these databases are supported:
 8. elasticsearch ([elasticsearch] (https://github.com/elastic/elasticsearch-js))
 9. elasticsearch6 ([elasticsearch] (https://github.com/elastic/elasticsearch-js)) - for Elasticsearch 5.x and 6.x
 10. dynamodb ([aws-sdk] (https://github.com/aws/aws-sdk-js))
+11. firestore ([@google-cloud/firestore] (https://github.com/googleapis/nodejs-firestore))
 
 ## own db implementation
 You can use your own db implementation by extending this...

lib/databases/firestore.js

@@ -0,0 +1,203 @@
+var util = require('util'),
+    _ = require('lodash'),
+    ConcurrencyError = require('../concurrencyError'),
+    gcFirestore = require('@google-cloud/firestore'),
+    Repository = require('../base'),
+    uuid = require('uuid').v4,
+    ViewModel = Repository.ViewModel;
+
+var collections = [];
+
+function Firestore(options) {
+  Repository.call(this);
+  this.options = options || {};
+}
+
+util.inherits(Firestore, Repository);
+
+function implementError (callback) {
+  var err = new Error('Storage method add is not implemented');
+  if (callback) callback(err);
+  throw err;
+}
+
+_.extend(Firestore.prototype, {
+
+  connect: function (callback) {
+    var self = this;
+    var options = this.options;
+    self.db = new gcFirestore(options);
+    if (callback) callback(null, self);
+  },
+
+  disconnect: function (callback) {
+    var self = this;
+    delete self.db;
+    if (callback) callback(null, self);
+  },
+
+  getNewId: function (callback) {
+    this.checkConnection();
+
+    var id = uuid().toString();
+    if (callback) callback(null, id);
+  },
+
+  get: function (id, callback) {
+    this.checkConnection();
+
+    if(_.isFunction(id)) {
+      callback = id;
+      id = null;
+    }
+
+    if (!id) {
+      id = uuid().toString();
+    }
+
+    var self = this;
+
+    var documentPath = this.collection + '/' + id;
+    var documentRef = this.db.doc(documentPath);
+
+    documentRef.get().then(function (documentSnapshot) {
+      var vm = new ViewModel(documentSnapshot.data() || { id }, self);
+      if (documentSnapshot.exists) {
+        vm.actionOnCommit = 'update';
+      } else {
+        vm.actionOnCommit = 'create';
+      }
+      callback(null, vm);
+    });
+  },
+
+  find: function (queryParams, queryOptions, callback) {
+    this.checkConnection();
+
+    // NOTE: Query should be an array, e.g., ['foo', '==', 'bar']
+    // queryOptions is ignored
+    var self = this;
+
+    var collectionRef = this.db.collection(this.collection);
+    var query = collectionRef.where.apply(collectionRef, queryParams);
+    query.get().then(function (querySnapshot) {
+      var vms = _.map(querySnapshot.docs, function(documentSnapshot) {
+        var vm = new ViewModel(documentSnapshot.data(), self);
+        vm.actionOnCommit = 'update';
+        return vm;
+      });
+      callback(null, vms);
+    });
+  },
+
+  findOne: function (query, queryOptions, callback) {
+    this.checkConnection();
+
+    // NOTE: Query should be an array, e.g., ['foo', '==', 'bar']
+    var self = this;
+    var collectionRef = this.db.collection(this.collection);
+    var query = collectionRef.where.apply(collectionRef, query);
+    query.limit(1).get().then(function (querySnapshot) {
+      if (querySnapshot.size == 0) {
+        callback(null, null);
+      }
+      querySnapshot.forEach(function (documentSnapshot) {
+        var vm = new ViewModel(documentSnapshot.data(), self);
+        vm.actionOnCommit = 'update';
+        callback(null, vm);
+      });
+    });
+  },
+
+    commit: function (vm, callback) {
+      this.checkConnection();
+
+      if (!vm.actionOnCommit) return callback(new Error('actionOnCommit is not defined!'));
+
+      switch(vm.actionOnCommit) {
+      case 'delete':
+        var documentPath = this.collection + '/' + vm.id;
+        var documentRef = this.db.doc(documentPath);
+        documentRef.delete().then(function () {
+          callback(null);
+        });
+        break;
+      case 'create':
+        var documentPath = this.collection + '/' + vm.id;
+        var documentRef = this.db.doc(documentPath);
+        documentRef.get().then(function (documentSnapshot) {
+          if (documentSnapshot.exists) {
+            return callback(new ConcurrencyError());
+          }
+          documentRef.set(vm.attributes).then(function () {
+            vm.actionOnCommit = 'update';
+            callback(null, vm);
+          });
+        });
+        break;
+      case 'update':
+        var documentPath = this.collection + '/' + vm.id;
+        var documentRef = this.db.doc(documentPath);
+        documentRef.get().then(function (documentSnapshot) {
+          if (!documentSnapshot.exists) {
+            return callback(new ConcurrencyError());
+          }
+          documentRef.update(vm.attributes).then(function () {
+            vm.actionOnCommit = 'update';
+            callback(null, vm);
+          });
+        });
+        break;
+      default:
+        return callback(new Error('Unknown actionOnCommit: ' + vm.actionOnCommit));
+      };
+  },
+
+  checkConnection: function (callback) {
+    if (this.collection) {
+      return;
+    }
+
+    if (collections.indexOf(this.collectionName) < 0) {
+      collections.push(this.collectionName)
+    }
+
+    this.collection = this.collectionName;
+    if (callback) callback(null);
+  },
+
+  clear: function (callback) {
+    this.checkConnection();
+
+    var self = this;
+    if (!this.collection) {
+      if (callback) callback(null);
+      return;
+    }
+
+    var collectionRef = this.db.collection(this.collection);
+    var query = collectionRef.get().then(function (querySnapshot) {
+      var writeBatch = self.db.batch();
+      querySnapshot.forEach(function (documentSnapshot) {
+        var documentPath = self.collection + '/' + documentSnapshot.id;
+        var documentRef = self.db.doc(documentPath);
+        writeBatch.delete(documentRef);
+      });
+      writeBatch.commit().then(function () {
+        if (callback) callback(null);
+      });
+    });
+  },
+
+  /**
+   * NEVER USE THIS FUNCTION!!! ONLY FOR TESTS!
+   * clears the complete store...
+   * @param {Function} callback the function that will be called when this action has finished [optional]
+   */
+  clearAll: function (callback) {
+    implementError(callback);
+  },
+
+});
+
+module.exports = Firestore;

package.json

@@ -21,6 +21,7 @@
     "uuid": "3.1.0"
   },
   "devDependencies": {
+    "@google-cloud/firestore": "^0.14.1",
     "aws-sdk": ">=2.123.0",
     "azure-storage": ">=0.3.0",
     "cradle": ">=0.6.7",