spike for prop notification

addon/index.js

@@ -1,6 +1,6 @@
 import { assert } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
-import { BufferedChangeset } from 'validated-changeset';
+import { BufferedChangeset, Change, keyInObject } from 'validated-changeset';
 import ArrayProxy from '@ember/array/proxy';
 import ObjectProxy from '@ember/object/proxy';
 import { notifyPropertyChange } from '@ember/object';
@@ -32,6 +32,33 @@ function maybeUnwrapProxy(o) {
   return isProxy(o) ? maybeUnwrapProxy(safeGet(o, 'content')) : o;
 }
 
+function tryContent(ctx) {
+  return ctx._content ? ctx._content : ctx.content ? ctx.content : ctx;
+}
+
+function deepNotifyPropertyChange(changeset, path) {
+  let paths = path.split('.');
+  let maybeDynamicPathToNotify = null,
+    lastPath = paths.pop(),
+    current = changeset,
+    i;
+
+  //If the path doesn't exists previously exist inside the CONTENT, this is a dynamic set.
+  let existsInContent = safeGet(changeset[CONTENT], path) !== undefined;
+
+  for (i = 0; i < paths.length; ++i) {
+    const curr = current[paths[i]];
+    if (existsInContent && curr && curr.content === curr.content) {
+      current = current[paths[i]];
+    } else {
+      maybeDynamicPathToNotify = paths[i];
+      break;
+    }
+  }
+  const pathToNotify = maybeDynamicPathToNotify ? maybeDynamicPathToNotify : lastPath;
+  notifyPropertyChange(tryContent(current), pathToNotify);
+}
+
 export class EmberChangeset extends BufferedChangeset {
   @tracked _changes;
   @tracked _errors;
@@ -110,7 +137,7 @@ export class EmberChangeset extends BufferedChangeset {
   addError(key, error) {
     super.addError(key, error);
 
-    notifyPropertyChange(this, key);
+    deepNotifyPropertyChange(this, key);
     // Return passed-in `error`.
     return error;
   }
@@ -123,7 +150,7 @@ export class EmberChangeset extends BufferedChangeset {
   pushErrors(key, ...newErrors) {
     const { value, validation } = super.pushErrors(key, ...newErrors);
 
-    notifyPropertyChange(this, key);
+    deepNotifyPropertyChange(this, key);
 
     return { value, validation };
   }
@@ -133,9 +160,21 @@ export class EmberChangeset extends BufferedChangeset {
    * Returns value or error
    */
   _setProperty({ key, value, oldValue }) {
-    super._setProperty({ key, value, oldValue });
+    let changes = this[CHANGES];
 
-    notifyPropertyChange(this, key);
+    //We always set
+    this.setDeep(changes, key, new Change(value), {
+      safeSet: this.safeSet,
+    });
+
+    //If the newValue is equals to the wrapped value, delete key from changes
+    if (oldValue === value && keyInObject(changes, key)) {
+      this._deleteKey(CHANGES, key);
+    }
+
+    //Notitify deep
+    deepNotifyPropertyChange(this, key);
+    notifyPropertyChange(this, 'changes');
   }
 
   /**
@@ -149,7 +188,7 @@ export class EmberChangeset extends BufferedChangeset {
   _notifyVirtualProperties(keys) {
     keys = super._notifyVirtualProperties(keys);
 
-    (keys || []).forEach((key) => notifyPropertyChange(this, key));
+    (keys || []).forEach((key) => deepNotifyPropertyChange(this, key));
 
     return;
   }
@@ -159,9 +198,7 @@ export class EmberChangeset extends BufferedChangeset {
    */
   _deleteKey(objName, key = '') {
     const result = super._deleteKey(objName, key);
-
-    notifyPropertyChange(this, key);
-
+    deepNotifyPropertyChange(this, key);
     return result;
   }
 

tests/unit/changeset-test.js

@@ -1780,15 +1780,32 @@ module('Unit | Utility | changeset', function (hooks) {
   test('observing #rollback values', async function (assert) {
     let res;
     let changeset = Changeset(dummyModel, dummyValidator);
-    changeset.addObserver('name', function () {
-      res = this.name;
+    //To consistently observe for changes (even for deep keys),
+    //we must adhere to a never changing value
+    //so the changeset.data (_content) is the silver bullet for now
+    //ember-changeset will keep notifying on it
+    //one downside is that you won't get the changeset as `this` inside the callback.
+    changeset.data.addObserver('name', function () {
+      res = changeset.get('name');
     });
     assert.equal(undefined, changeset.get('name'), 'initial value');
     changeset.set('name', 'Jack');
     assert.equal('Jack', res, 'observer fired when setting value');
     changeset.rollback();
     assert.equal(undefined, res, 'observer fired with the value name was rollback to');
   });
+  test('observing deep keys on .data works', async function (assert) {
+    let res;
+    let changeset = Changeset(dummyModel, dummyValidator);
+    changeset.data.addObserver('some.really.nested.path', function () {
+      res = changeset.get('some.really.nested.path');
+    });
+    assert.equal(undefined, changeset.get('some.really.nested.path'), 'initial value');
+    changeset.set('some.really.nested.path', 'Jack');
+    assert.equal('Jack', res, 'observer fired when setting value some.really.nested.path');
+    changeset.rollback();
+    assert.equal(undefined, res, 'observer fired with the value some.really.nested.path was rollback to');
+  });
 
   test('can update nested keys after rollback changes.', async function (assert) {
     let expectedResult = {