Allow custom properties to Change Model

Allow custom properties to Change Model, and make change
filter customizable through mixins to allow to add the
cutom property to the filter.

fix failing test

Author: buildymcbuildy

common/models/change.js

@@ -186,16 +186,32 @@ module.exports = function(Change) {
 
     cb = cb || utils.createPromiseCallback();
 
-    change.currentRevision(function(err, rev) {
+    var model = this.getModelCtor();
+    var id = this.getModelId();
+
+    model.findById(id, function(err, inst) {
       if (err) return cb(err);
 
+      if (inst) {
+        inst.fillCustomChangeProperties(change, function() {
+          var rev = Change.revisionForInst(inst);
+          prepareAndDoRectify(rev);
+        });
+      } else {
+        prepareAndDoRectify(null);
+      }
+    });
+
+    return cb.promise;
+
+    function prepareAndDoRectify(rev) {
       // avoid setting rev and prev to the same value
       if (currentRev === rev) {
         change.debug('rev and prev are equal (not updating anything)');
         return cb(null, change);
       }
 
-      // FIXME(@bajtos) Allo callers to pass in the checkpoint value
+      // FIXME(@bajtos) Allow callers to pass in the checkpoint value
       // (or even better - a memoized async function to get the cp value)
       // That will enable `rectifyAll` to cache the checkpoint value
       change.constructor.getCheckpointModel().current(
@@ -204,8 +220,7 @@ module.exports = function(Change) {
           doRectify(checkpoint, rev);
         }
       );
-    });
-    return cb.promise;
+    }
 
     function doRectify(checkpoint, rev) {
       if (rev) {
@@ -230,7 +245,7 @@ module.exports = function(Change) {
           if (currentRev) {
             change.prev = currentRev;
           } else if (!change.prev) {
-            change.debug('ERROR - could not determing prev');
+            change.debug('ERROR - could not determine prev');
             change.prev = Change.UNKNOWN;
           }
           change.debug('updated prev');

lib/persisted-model.js

@@ -1064,17 +1064,16 @@ module.exports = function(registry) {
     var idName = this.dataSource.idName(this.modelName);
     var Change = this.getChangeModel();
     var model = this;
+    var changeFilter = this.createChangeFilter(since, filter);
 
     filter = filter || {};
     filter.fields = {};
     filter.where = filter.where || {};
     filter.fields[idName] = true;
 
     // TODO(ritch) this whole thing could be optimized a bit more
-    Change.find({ where: {
-      checkpoint: { gte: since },
-      modelName: this.modelName
-    }}, function(err, changes) {
+
+    Change.find(changeFilter, function(err, changes) {
       if (err) return callback(err);
       if (!Array.isArray(changes) || changes.length === 0) return callback(null, []);
       var ids = changes.map(function(change) {
@@ -1738,11 +1737,15 @@ module.exports = function(registry) {
     assert(BaseChangeModel,
       'Change model must be defined before enabling change replication');
 
+    var additionalChangeModelProperties = {};
+
+    if (this.settings.additionalChangeModelProperties) {
+      additionalChangeModelProperties = this.settings.additionalChangeModelProperties;
+    }
+
     this.Change = BaseChangeModel.extend(this.modelName + '-change',
-      {},
-      {
-        trackModel: this
-      }
+      additionalChangeModelProperties,
+      {trackModel: this}
     );
 
     if (this.dataSource) {
@@ -1763,7 +1766,6 @@ module.exports = function(registry) {
       self.Change.getCheckpointModel().attachTo(self.dataSource);
     }
   };
-
   PersistedModel.rectifyAllChanges = function(callback) {
     this.getChangeModel().rectifyAll(callback);
   };
@@ -1908,6 +1910,80 @@ module.exports = function(registry) {
     }
   };
 
+  /**
+   * Get the filter for searching related changes. Override this function, if need to use properties from the model
+   * filter as part the change search filter
+   *
+   * example override for this function(in a mixin) when a custom property is used in change model, using model instance
+   * property value in the change filter.
+   *
+   * module.exports = (TargetModel, config) => {
+   *   var originalFilterFactory = TargetModel.createChangeFilter;
+   *
+   *   TargetModel.createChangeFilter = function (since, modelFilter) {
+   *     var customProperty = TargetModel.settings.changeCustomProperty;
+   *
+   *     var filter = originalFilterFactory.call(this, since, modelFilter);
+   *     if (modelFilter && modelFilter.where && modelFilter.where[customProperty]) {
+   *       filter.where[customProperty] = modelFilter.where[customProperty];
+   *     }
+   *     return filter;
+   *   };
+   * };
+   *
+   * @param {Number}   since    Return only changes since this checkpoint.
+   * @param {Object}   modelFilter   filter used for the model
+   * @returns {Object} The filter object to pass to `Change.find()`, typically `{{where: {checkpoint: {gte: *}, modelName: *}}}`
+   */
+  PersistedModel.createChangeFilter = function(since, modelFilter) {
+    return {
+      where: {
+        checkpoint: {gte: since},
+        modelName: this.modelName
+      }
+    };
+  };
+
+  /**
+   * Add custom change model property data.
+   * Override this function if custom properties exist in your change model which need to be filled during change creation
+   *
+   * example override for this function(in a mixin) to fill custom properties during change model creation
+   *
+   * module.exports = (TargetModel, config) => {
+   *   var originalCustomChangeDataFactory = TargetModel.prototype.fillCustomChangeProperties;
+   *
+   *   TargetModel.prototype.fillCustomChangeProperties = function (change, cb) {
+   *     var changeCustomPropertyValue = null;
+   *     var changeCustomProperty;
+   *     var inst = this;
+   *
+   *     originalCustomChangeDataFactory.call(this, change, function (err) {
+   *       if (err) return cb(err);
+   *       if (TargetModel && TargetModel.settings && TargetModel.settings.changeCustomProperty) {
+   *         changeCustomProperty = TargetModel.settings.changeCustomProperty;
+   *       }
+   *
+   *       if (changeCustomProperty && inst && inst[changeCustomProperty]) {
+   *         changeCustomPropertyValue = inst[changeCustomProperty];
+   *       }
+   *
+   *       change[changeCustomProperty] = changeCustomPropertyValue;
+   *
+   *       cb(null);
+   *     });
+   *   };
+   * };
+   *
+   *
+   * @callback {Function} callback
+   * @param change
+   */
+  PersistedModel.prototype.fillCustomChangeProperties = function(change, cb) {
+    // no-op by default
+    cb(null);
+  };
+
   PersistedModel.setup();
 
   return PersistedModel;

test/change.test.js

@@ -6,10 +6,10 @@
 var async = require('async');
 var expect = require('chai').expect;
 
-var Change;
-var TestModel;
-
 describe('Change', function() {
+  var Change;
+  var TestModel;
+
   beforeEach(function() {
     var memory = loopback.createDataSource({
       connector: loopback.Memory
@@ -320,7 +320,6 @@ describe('Change', function() {
       change.rectify()
         .then(function(ch) {
           assert.equal(ch.rev, test.revisionForModel);
-
           done();
         })
         .catch(done);
@@ -608,3 +607,73 @@ describe('Change', function() {
     });
   });
 });
+
+describe('Change with with custom properties', function() {
+  var ChangeWithCustomProperty;
+  var TestModelWithModifiedChangeModel;
+  var customProperty = 'tenantId';
+
+  beforeEach(function() {
+    var memory = loopback.createDataSource({
+      connector: loopback.Memory
+    });
+
+    var additionalChangeModelProperties = {};
+    additionalChangeModelProperties[customProperty] = {type: 'string'};
+
+    TestModelWithModifiedChangeModel = loopback.PersistedModel
+    .extend('ChangeTestModel',
+    {
+      id: {id: true, type: 'string', defaultFn: 'guid'}
+    },
+    {
+      trackChanges: true,
+      additionalChangeModelProperties: additionalChangeModelProperties
+    });
+    this.modelName = TestModelWithModifiedChangeModel.modelName;
+
+    TestModelWithModifiedChangeModel.prototype.fillCustomChangeProperties = function(change, cb) {
+      var customPropertyValue = null;
+      var inst = this;
+
+      if (inst && inst[customProperty]) {
+        customPropertyValue = inst[customProperty];
+      }
+      change[customProperty] = customPropertyValue;
+
+      cb(null);
+    };
+
+    TestModelWithModifiedChangeModel.attachTo(memory);
+    TestModelWithModifiedChangeModel._defineChangeModel();
+    ChangeWithCustomProperty = TestModelWithModifiedChangeModel.getChangeModel();
+  });
+
+  describe('change.rectify', function() {
+    var change;
+    var customPropertyValue = '123';
+
+    beforeEach(function() {
+      var test = this;
+
+      test.data = {
+        foo: 'bar'
+      };
+      test.data[customProperty] = customPropertyValue;
+
+      return TestModelWithModifiedChangeModel.create(test.data)
+      .then(function(model) {
+        return ChangeWithCustomProperty.findOrCreateChange(TestModelWithModifiedChangeModel.modelName, model.id);
+      }).then(function(ch) {
+        change = ch;
+      });
+    });
+
+    it('creates a new change with the custom property', function() {
+      return change.rectify()
+      .then(function(ch) {
+        assert.equal(ch[customProperty], customPropertyValue);
+      });
+    });
+  });
+});