Improve dot notation for updating nested objects

integration/test/ParseObjectTest.js

@@ -229,6 +229,181 @@ describe('Parse Object', () => {
     });
   });
 
+  it('can increment nested fields', async () => {
+    const obj = new TestObject();
+    obj.set('objectField', { number: 5 });
+    assert.equal(obj.get('objectField').number, 5);
+    await obj.save();
+
+    obj.increment('objectField.number', 15);
+    assert.equal(obj.get('objectField').number, 20);
+    await obj.save();
+
+    assert.equal(obj.get('objectField').number, 20);
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').number, 20);
+  });
+
+  it('can increment non existing field', async () => {
+    const obj = new TestObject();
+    obj.set('objectField', { number: 5 });
+    await obj.save();
+
+    obj.increment('objectField.unknown', 15);
+    assert.deepEqual(obj.get('objectField'), {
+      number: 5,
+      unknown: 15,
+    });
+    await obj.save();
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').number, 5);
+    assert.equal(result.get('objectField').unknown, 15);
+  });
+
+  it('can increment nested fields two levels', async () => {
+    const obj = new TestObject();
+    obj.set('objectField', { foo: { bar: 5 } });
+    assert.equal(obj.get('objectField').foo.bar, 5);
+    await obj.save();
+
+    obj.increment('objectField.foo.bar', 15);
+    assert.equal(obj.get('objectField').foo.bar, 20);
+    await obj.save();
+
+    assert.equal(obj.get('objectField').foo.bar, 20);
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').foo.bar, 20);
+  });
+
+  it('can increment nested fields without object', async () => {
+    const obj = new TestObject();
+    obj.set('hello', 'world');
+    await obj.save();
+
+    obj.increment('hello.dot', 15);
+    try  {
+      await obj.save();
+      assert.equal(false, true);
+    } catch(error) {
+      assert.equal(error.message, "Cannot create property 'dot' on string 'world'");
+    }
+  });
+
+  it('can set nested fields', async () => {
+    const obj = new TestObject({ objectField: { number: 5 } });
+    assert.equal(obj.get('objectField').number, 5);
+    await obj.save();
+
+    assert.equal(obj.get('objectField').number, 5);
+    obj.set('objectField.number', 20);
+    assert.equal(obj.get('objectField').number, 20);
+    await obj.save();
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').number, 20);
+  });
+
+  it('can set non existing fields', async () => {
+    const obj = new TestObject();
+    obj.set('objectField', { number: 5 });
+    await obj.save();
+
+    obj.set('objectField.unknown', 20);
+    await obj.save();
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').number, 5);
+    assert.equal(result.get('objectField').unknown, 20);
+  });
+
+  it('ignore set nested fields on new object', async () => {
+    const obj = new TestObject();
+    obj.set('objectField.number', 5);
+    assert.deepEqual(obj._getPendingOps()[0], {});
+    assert.equal(obj.get('objectField'), undefined);
+
+    await obj.save();
+    assert.equal(obj.get('objectField'), undefined);
+  });
+
+  it('can set nested fields two levels', async () => {
+    const obj = new TestObject({ objectField: { foo: { bar: 5 } } });
+    assert.equal(obj.get('objectField').foo.bar, 5);
+    await obj.save();
+
+    assert.equal(obj.get('objectField').foo.bar, 5);
+    obj.set('objectField.foo.bar', 20);
+    assert.equal(obj.get('objectField').foo.bar, 20);
+    await obj.save();
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').foo.bar, 20);
+  });
+
+  it('can unset nested fields', async () => {
+    const obj = new TestObject({
+      objectField: {
+        number: 5,
+        string: 'hello',
+      }
+    });
+    await obj.save();
+
+    obj.unset('objectField.number');
+    assert.equal(obj.get('objectField').number, undefined);
+    assert.equal(obj.get('objectField').string, 'hello');
+    await obj.save();
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').number, undefined);
+    assert.equal(result.get('objectField').string, 'hello');
+  });
+
+  it('can unset nested fields two levels', async () => {
+    const obj = new TestObject({
+      objectField: {
+        foo: {
+          bar: 5,
+        },
+        string: 'hello',
+      }
+    });
+    await obj.save();
+
+    obj.unset('objectField.foo.bar');
+    assert.equal(obj.get('objectField').foo.bar, undefined);
+    assert.equal(obj.get('objectField').string, 'hello');
+    await obj.save();
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').foo.bar, undefined);
+    assert.equal(result.get('objectField').string, 'hello');
+  });
+
+  it('can unset non existing fields', async () => {
+    const obj = new TestObject();
+    obj.set('objectField', { number: 5 });
+    await obj.save();
+
+    obj.unset('objectField.unknown');
+    await obj.save();
+
+    const query = new Parse.Query(TestObject);
+    const result = await query.get(obj.id);
+    assert.equal(result.get('objectField').number, 5);
+    assert.equal(result.get('objectField').unknown, undefined);
+  });
+
   it('can set keys to null', (done) => {
     const obj = new TestObject();
     obj.set('foo', null);

src/ObjectStateMutations.js

@@ -123,7 +123,18 @@ export function estimateAttributes(serverData: AttributeMap, pendingOps: Array<O
           );
         }
       } else {
-        data[attr] = pendingOps[i][attr].applyTo(data[attr]);
+        if (attr.includes('.')) {
+          // convert a.b.c into { a: { b: { c: value } } }
+          const fields = attr.split('.');
+          const last = fields[fields.length - 1];
+          let object = Object.assign({}, data);
+          for (let i = 0; i < fields.length - 1; i++) {
+            object = object[fields[i]];
+          }
+          object[last] = pendingOps[i][attr].applyTo(object[last]);
+        } else {
+          data[attr] = pendingOps[i][attr].applyTo(data[attr]);
+        }
       }
     }
   }

src/ParseObject.js

@@ -282,8 +282,24 @@ class ParseObject {
     const dirtyObjects = this._getDirtyObjectAttributes();
     const json = {};
     let attr;
+
     for (attr in dirtyObjects) {
-      json[attr] = new SetOp(dirtyObjects[attr]).toJSON();
+      let isDotNotation = false;
+      for (let i = 0; i < pending.length; i += 1) {
+        for (const field in pending[i]) {
+          // Dot notation operations are handled later
+          if (field.includes('.')) {
+            const fieldName = field.split('.')[0];
+            if (fieldName === attr) {
+              isDotNotation = true;
+              break;
+            }
+          }
+        }
+      }
+      if (!isDotNotation) {
+        json[attr] = new SetOp(dirtyObjects[attr]).toJSON();
+      }
     }
     for (attr in pending[0]) {
       json[attr] = pending[0][attr].toJSON();
@@ -582,8 +598,8 @@ class ParseObject {
   /**
    * Sets a hash of model attributes on the object.
    *
-   * <p>You can call it with an object containing keys and values, or with one
-   * key and value.  For example:<pre>
+   * <p>You can call it with an object containing keys and values, with one
+   * key and value, or dot notation.  For example:<pre>
    *   gameTurn.set({
    *     player: player1,
    *     diceRoll: 2
@@ -601,6 +617,8 @@ class ParseObject {
    *
    *   game.set("finished", true);</pre></p>
    *
+   *   game.set("player.score", 10);</pre></p>
+   *
    * @param {String} key The key to set.
    * @param {} value The value to give it.
    * @param {Object} options A set of options for the set.
@@ -661,8 +679,18 @@ class ParseObject {
       }
     }
 
-    // Calculate new values
     const currentAttributes = this.attributes;
+
+    // Only set nested fields if exists
+    const serverData = this._getServerData();
+    if (typeof key === 'string' && key.includes('.')) {
+      const field = key.split('.')[0];
+      if (!serverData[field]) {
+        return this;
+      }
+    }
+
+    // Calculate new values
     const newValues = {};
     for (const attr in newOps) {
       if (newOps[attr] instanceof RelationOp) {
@@ -910,7 +938,7 @@ class ParseObject {
       );
     }
     for (const key in attrs) {
-      if (!(/^[A-Za-z][0-9A-Za-z_]*$/).test(key)) {
+      if (!(/^[A-Za-z][0-9A-Za-z_.]*$/).test(key)) {
         return new ParseError(ParseError.INVALID_KEY_NAME);
       }
     }

src/__tests__/ObjectStateMutations-test.js

@@ -119,6 +119,22 @@ describe('ObjectStateMutations', () => {
     expect(attributes.likes.key).toBe('likes');
   });
 
+  it('can estimate attributes for nested documents', () => {
+    const serverData = { objectField: { counter: 10 } };
+    let pendingOps = [{ 'objectField.counter': new ParseOps.IncrementOp(2) }];
+    expect(ObjectStateMutations.estimateAttributes(serverData, pendingOps, 'someClass', 'someId')).toEqual({
+      objectField: {
+        counter: 12
+      },
+    });
+    pendingOps = [{ 'objectField.counter': new ParseOps.SetOp(20) }];
+    expect(ObjectStateMutations.estimateAttributes(serverData, pendingOps, 'someClass', 'someId')).toEqual({
+      objectField: {
+        counter: 20
+      },
+    });
+  });
+
   it('can commit changes from the server', () => {
     const serverData = {};
     const objectCache = {};

src/__tests__/ParseObject-test.js

@@ -474,6 +474,45 @@ describe('ParseObject', () => {
     expect(o2.attributes).toEqual({ age: 41 });
   });
 
+  it('can set nested field', () => {
+    const o = new ParseObject('Person');
+    o._finishFetch({
+      objectId: 'setNested',
+      objectField: {
+        number: 5
+      },
+      otherField: {},
+    });
+
+    expect(o.attributes).toEqual({
+      objectField: { number: 5 },
+      otherField: {},
+    });
+    o.set('otherField', { hello: 'world' });
+    o.set('objectField.number', 20);
+
+    expect(o.attributes).toEqual({
+      objectField: { number: 20 },
+      otherField: { hello: 'world' },
+    });
+    expect(o.op('objectField.number') instanceof SetOp).toBe(true);
+    expect(o.dirtyKeys()).toEqual(['otherField', 'objectField.number', 'objectField']);
+    expect(o._getSaveJSON()).toEqual({
+      'objectField.number': 20,
+      otherField: { hello: 'world' },
+    });
+  });
+
+  it('ignore set nested field on new object', () => {
+    const o = new ParseObject('Person');
+    o.set('objectField.number', 20);
+
+    expect(o.attributes).toEqual({});
+    expect(o.op('objectField.number') instanceof SetOp).toBe(false);
+    expect(o.dirtyKeys()).toEqual([]);
+    expect(o._getSaveJSON()).toEqual({});
+  });
+
   it('can add elements to an array field', () => {
     const o = new ParseObject('Schedule');
     o.add('available', 'Monday');
@@ -650,6 +689,10 @@ describe('ParseObject', () => {
     expect(o.validate({
       noProblem: 'here'
     })).toBe(false);
+
+    expect(o.validate({
+      'dot.field': 'here'
+    })).toBe(false);
   });
 
   it('validates attributes on set()', () => {