feat: Add two-way binding of Parse object properties with Parse.Object.bind.key = value

integration/test/ParseObjectTest.js

@@ -2108,6 +2108,75 @@ describe('Parse Object', () => {
     });
   });
 
+  it('allow binding', async () => {
+    const object = new Parse.Object('TestObject2');
+    object.bind.foo = 'bar';
+    await object.save();
+    expect(object.bind.foo).toBe('bar');
+    expect(object.get('foo')).toBe('bar');
+    expect(Object.keys(object.toJSON()).sort()).toEqual([
+      'createdAt',
+      'foo',
+      'objectId',
+      'updatedAt',
+    ]);
+
+    const query = new Parse.Query('TestObject2');
+    const result = await query.get(object.id);
+    expect(result.bind.foo).toBe('bar');
+    expect(result.get('foo')).toBe('bar');
+    expect(result.id).toBe(object.id);
+    result.bind.foo = 'baz';
+    expect(result.get('foo')).toBe('baz');
+    await result.save();
+
+    const afterSave = await query.get(object.id);
+    expect(afterSave.bind.foo).toBe('baz');
+    expect(afterSave.get('foo')).toBe('baz');
+  });
+
+  it('allow binding on pointers', async () => {
+    const grandparent = new Parse.Object('DotGrandparent');
+    grandparent.bind.foo = 'bar1';
+    const parent = new Parse.Object('DotParent');
+    parent.bind.foo = 'bar2';
+    grandparent.bind.parent = parent;
+    const child = new Parse.Object('DotChild');
+    child.bind.foo = 'bar3';
+    parent.bind.child = child;
+    await Parse.Object.saveAll([child, parent, grandparent]);
+    expect(grandparent.bind.foo).toBe('bar1');
+    expect(grandparent.bind.parent.bind.foo).toBe('bar2');
+    expect(grandparent.bind.parent.bind.child.bind.foo).toBe('bar3');
+    expect(grandparent.get('foo')).toBe('bar1');
+    expect(grandparent.get('parent').get('foo')).toBe('bar2');
+    expect(grandparent.get('parent').get('child').get('foo')).toBe('bar3');
+    expect(Object.keys(grandparent.toJSON()).sort()).toEqual([
+      'createdAt',
+      'foo',
+      'objectId',
+      'parent',
+      'updatedAt',
+    ]);
+    expect(Object.keys(grandparent.bind.parent.toJSON()).sort()).toEqual([
+      'child',
+      'createdAt',
+      'foo',
+      'objectId',
+      'updatedAt',
+    ]);
+    expect(Object.keys(grandparent.bind.parent.bind.child.toJSON()).sort()).toEqual([
+      'createdAt',
+      'foo',
+      'objectId',
+      'updatedAt',
+    ]);
+    const grandparentQuery = await new Parse.Query('DotGrandparent')
+      .include('parent', 'parent.child')
+      .first();
+    expect(grandparentQuery.bind.parent.bind.child.bind.foo).toEqual('bar3');
+  });
+
   describe('allowCustomObjectId saveAll', () => {
     it('can save without setting an objectId', async () => {
       await reconfigureServer({ allowCustomObjectId: true });

integration/test/ParseUserTest.js

@@ -1042,6 +1042,29 @@ describe('Parse User', () => {
     Parse.CoreManager.set('ENCRYPTED_KEY', null);
   });
 
+  it('allow binding', async () => {
+    const user = new Parse.User();
+    const username = uuidv4();
+    user.bind.username = username;
+    user.bind.password = username;
+    user.bind.foo = 'bar';
+    await user.#();
+    expect(Object.keys(user.toJSON()).sort()).toEqual([
+      'createdAt',
+      'foo',
+      'objectId',
+      'sessionToken',
+      'updatedAt',
+      'username',
+    ]);
+    expect(user.bind.username).toBe(username);
+    expect(user.bind.foo).toBe('bar');
+    const userFromQuery = await new Parse.Query(Parse.User).first();
+    expect(userFromQuery.bind.username).toBe(username);
+    expect(userFromQuery.bind.password).toBeUndefined();
+    expect(userFromQuery.bind.foo).toBe('bar');
+  });
+
   it('fix GHSA-wvh7-5p38-2qfc', async () => {
     Parse.User.enableUnsafeCurrentUser();
     const user = new Parse.User();

package.json

@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "@babel/runtime-corejs3": "7.21.0",
+    "deepcopy": "2.1.0",
     "idb-keyval": "6.2.0",
     "react-native-crypto-js": "1.0.0",
     "uuid": "9.0.0",

src/ParseObject.js

@@ -14,6 +14,7 @@ import ParseError from './ParseError';
 import ParseFile from './ParseFile';
 import { when, continueWhile, resolvingPromise } from './promiseUtils';
 import { DEFAULT_PIN, PIN_PREFIX } from './LocalDatastoreUtils';
+import proxyHandler from './proxy';
 
 import {
   opFromJSON,
@@ -136,6 +137,7 @@ class ParseObject {
     if (toSet && !this.set(toSet, options)) {
       throw new Error("Can't create an invalid Parse Object");
     }
+    this._createProxy();
   }
 
   /**
@@ -148,6 +150,17 @@ class ParseObject {
   _objCount: number;
   className: string;
 
+  /**
+   * Bind, used for two way directonal binding using
+   *
+   * When using a responsive framework that supports binding to an object's keys, use `object.bind.key` for dynamic updating of a Parse.Object
+   *
+   * `object.get("key")` and `object.set("set")` is preffered for one way binding.
+   *
+   * @property {object} bind
+   */
+  bind: AttributeMap;
+
   /* Prototype getters / setters */
 
   get attributes(): AttributeMap {
@@ -367,6 +380,7 @@ class ParseObject {
       decoded.updatedAt = decoded.createdAt;
     }
     stateController.commitServerChanges(this._getStateIdentifier(), decoded);
+    this._createProxy();
   }
 
   _setExisted(existed: boolean) {
@@ -377,6 +391,10 @@ class ParseObject {
     }
   }
 
+  _createProxy() {
+    this.bind = new Proxy(this, proxyHandler);
+  }
+
   _migrateId(serverId: string) {
     if (this._localId && serverId) {
       if (singleInstance) {
@@ -1098,6 +1116,8 @@ class ParseObject {
       }
     }
     this._clearPendingOps(keysToRevert);
+    this._createProxy();
+    return this;
   }
 
   /**
@@ -1332,9 +1352,15 @@ class ParseObject {
     }
     const controller = CoreManager.getObjectController();
     const unsaved = options.cascadeSave !== false ? unsavedChildren(this) : null;
-    return controller.save(unsaved, saveOptions).then(() => {
-      return controller.save(this, saveOptions);
-    });
+    return controller
+      .save(unsaved, saveOptions)
+      .then(() => {
+        return controller.save(this, saveOptions);
+      })
+      .then(res => {
+        this._createProxy();
+        return res;
+      });
   }
 
   /**
@@ -1972,6 +1998,7 @@ class ParseObject {
           throw new Error("Can't create an invalid Parse Object");
         }
       }
+      this._createProxy();
     };
     if (classMap[adjustedClassName]) {
       ParseObjectSubclass = classMap[adjustedClassName];

src/__tests__/Parse-test.js

@@ -6,6 +6,8 @@ jest.dontMock('../Parse');
 jest.dontMock('../LocalDatastore');
 jest.dontMock('crypto-js/aes');
 jest.setMock('../EventuallyQueue', { poll: jest.fn() });
+jest.dontMock('../proxy');
+jest.dontMock('deepcopy');
 
 global.indexedDB = require('./test_helpers/mockIndexedDB');
 const CoreManager = require('../CoreManager');

src/__tests__/ParseObject-test.js

@@ -23,6 +23,8 @@ jest.dontMock('../UniqueInstanceStateController');
 jest.dontMock('../unsavedChildren');
 jest.dontMock('../ParseACL');
 jest.dontMock('../LocalDatastore');
+jest.dontMock('../proxy');
+jest.dontMock('deepcopy');
 
 jest.mock('../uuid', () => {
   let value = 0;
@@ -2568,6 +2570,76 @@ describe('ParseObject', () => {
       jest.runAllTicks();
     });
   });
+  it('can save object with dot notation', async () => {
+    CoreManager.getRESTController()._setXHR(
+      mockXHR([
+        {
+          status: 200,
+          response: {
+            objectId: 'P1',
+          },
+        },
+      ])
+    );
+    const obj = new ParseObject('TestObject');
+    obj.bind.name = 'Foo';
+    expect(Object.keys(obj.bind)).toEqual(['name'])
+    await obj.save();
+    expect(obj.bind.name).toBe('Foo');
+    expect(obj.toJSON()).toEqual({ name: 'Foo', objectId: 'P1' });
+    expect(obj.attributes).toEqual({ name: 'Foo' });
+    expect(obj.get('name')).toBe('Foo');
+  });
+
+  it('can set and revert deep with dot notation', async () => {
+    CoreManager.getRESTController()._setXHR(
+      mockXHR([
+        {
+          status: 200,
+          response: { objectId: 'I1', nested: { foo: { a: 1 } } },
+        },
+      ])
+    );
+    const object = await new ParseObject('Test').save();
+    expect(object.id).toBe('I1');
+    expect(object.bind.nested.foo).toEqual({ a: 1 });
+    object.bind.a = '123';
+    object.bind.nested.foo.a = 2;
+    expect(object.bind.nested.foo).toEqual({ a: 2 });
+    expect(object.dirtyKeys()).toEqual(['a', 'nested']);
+    object.revert('a');
+    expect(object.dirtyKeys()).toEqual(['nested']);
+    object.revert();
+    expect(object.bind.nested.foo).toEqual({ a: 1 });
+    expect(object.bind.a).toBeUndefined();
+    expect(object.dirtyKeys()).toEqual([]);
+    object.bind.nested.foo.a = 2;
+    expect(object.bind.nested.foo).toEqual({ a: 2 });
+  });
+
+  it('can delete with dot notation', async () => {
+    const obj = new ParseObject('TestObject');
+    obj.bind.name = 'Foo';
+    expect(obj.attributes).toEqual({ name: 'Foo' });
+    expect(obj.get('name')).toBe('Foo');
+    delete obj.bind.name;
+    expect(obj.op('name') instanceof ParseOp.UnsetOp).toEqual(true);
+    expect(obj.get('name')).toBeUndefined();
+    expect(obj.attributes).toEqual({});
+  });
+
+  it('can delete nested keys dot notation', async () => {
+    const obj = new ParseObject('TestObject', { name: { foo: { bar: 'a' } } });
+    delete obj.bind.name.foo.bar;
+    expect(obj.bind.name.foo).toEqual({});
+  });
+
+  it('can update nested array with dot notation', async () => {
+    const obj = new ParseObject('TestObject', { name: [{foo: { bar: 'a' } }] });
+    obj.bind.name[0].foo.bar = 'b';
+    expect(obj.get('name')).toEqual([{foo: { bar: 'b' } }]);
+  });
+
 });
 
 describe('ObjectController', () => {

src/__tests__/ParseQuery-test.js

@@ -11,6 +11,8 @@ jest.dontMock('../ObjectStateMutations');
 jest.dontMock('../LocalDatastore');
 jest.dontMock('../OfflineQuery');
 jest.dontMock('../LiveQuerySubscription');
+jest.dontMock('../proxy');
+jest.dontMock('deepcopy');
 
 jest.mock('../uuid', () => {
   let value = 0;
@@ -3797,4 +3799,19 @@ describe('ParseQuery LocalDatastore', () => {
     expect(subscription.sessionToken).toBe('r:test');
     expect(subscription.query).toEqual(query);
   });
+
+  it('can query with dot notation', async () => {
+    CoreManager.setQueryController({
+      aggregate() {},
+      find() {
+        return Promise.resolve({
+          results: [{ objectId: 'I1', size: 'small', name: 'Product 3' }],
+        });
+      },
+    });
+    const object = await new ParseQuery('Item').equalTo('size', 'small').first();
+    expect(object.id).toBe('I1');
+    expect(object.bind.size).toBe('small');
+    expect(object.bind.name).toBe('Product 3');
+  });
 });