Merge branch 'master' into LDS

Author: dplewis

2.0.0.md

@@ -91,3 +91,15 @@ Promise.all([promise1, promise2, promise3])
 
 });
 ```
+
+:warning: Whereas `Parse.Promise.always`, `Promise.finally` callback don't receive any arguments, and don't resolve with a new argument to pass to the next promise in chain.
+
+```js
+// before
+Parse.Promise.as(1).always((val) => val + 1).then((result) => console.log(result))
+// will print 2
+
+// after
+Promise.resolve(1).finally(() => 2).then((result) => console.log(result))
+// will print 1
+```

integration/test/ParseObjectTest.js

@@ -1347,6 +1347,93 @@ describe('Parse Object', () => {
     });
   });
 
+  it('can fetchWithInclude', async () => {
+    const parent = new TestObject();
+    const child = new TestObject();
+    child.set('field', 'isChild');
+    parent.set('child', child);
+    await parent.save();
+
+    const obj1 = TestObject.createWithoutData(parent.id);
+    const fetchedObj1 = await obj1.fetchWithInclude('child');
+    assert.equal(obj1.get('child').get('field'), 'isChild');
+    assert.equal(fetchedObj1.get('child').get('field'), 'isChild');
+
+    const obj2 = TestObject.createWithoutData(parent.id);
+    const fetchedObj2 = await obj2.fetchWithInclude(['child']);
+    assert.equal(obj2.get('child').get('field'), 'isChild');
+    assert.equal(fetchedObj2.get('child').get('field'), 'isChild');
+
+    const obj3 = TestObject.createWithoutData(parent.id);
+    const fetchedObj3 = await obj3.fetchWithInclude([ ['child'] ]);
+    assert.equal(obj3.get('child').get('field'), 'isChild');
+    assert.equal(fetchedObj3.get('child').get('field'), 'isChild');
+  });
+
+  it('can fetchWithInclude dot notation', async () => {
+    const parent = new TestObject();
+    const child = new TestObject();
+    const grandchild = new TestObject();
+    grandchild.set('field', 'isGrandchild');
+    child.set('grandchild', grandchild);
+    parent.set('child', child);
+    await Parse.Object.saveAll([parent, child, grandchild]);
+
+    const obj1 = TestObject.createWithoutData(parent.id);
+    await obj1.fetchWithInclude('child.grandchild');
+    assert.equal(obj1.get('child').get('grandchild').get('field'), 'isGrandchild');
+
+    const obj2 = TestObject.createWithoutData(parent.id);
+    await obj2.fetchWithInclude(['child.grandchild']);
+    assert.equal(obj2.get('child').get('grandchild').get('field'), 'isGrandchild');
+
+    const obj3 = TestObject.createWithoutData(parent.id);
+    await obj3.fetchWithInclude([ ['child.grandchild'] ]);
+    assert.equal(obj3.get('child').get('grandchild').get('field'), 'isGrandchild');
+  });
+
+  it('can fetchAllWithInclude', async () => {
+    const parent = new TestObject();
+    const child = new TestObject();
+    child.set('field', 'isChild');
+    parent.set('child', child);
+    await parent.save();
+
+    const obj1 = TestObject.createWithoutData(parent.id);
+    await Parse.Object.fetchAllWithInclude([obj1], 'child');
+    assert.equal(obj1.get('child').get('field'), 'isChild');
+
+    const obj2 = TestObject.createWithoutData(parent.id);
+    await Parse.Object.fetchAllWithInclude([obj2], ['child']);
+    assert.equal(obj2.get('child').get('field'), 'isChild');
+
+    const obj3 = TestObject.createWithoutData(parent.id);
+    await Parse.Object.fetchAllWithInclude([obj3], [ ['child'] ]);
+    assert.equal(obj3.get('child').get('field'), 'isChild');
+  });
+
+  it('can fetchAllWithInclude dot notation', async () => {
+    const parent = new TestObject();
+    const child = new TestObject();
+    const grandchild = new TestObject();
+    grandchild.set('field', 'isGrandchild');
+    child.set('grandchild', grandchild);
+    parent.set('child', child);
+    await Parse.Object.saveAll([parent, child, grandchild]);
+
+    const obj1 = TestObject.createWithoutData(parent.id);
+    await Parse.Object.fetchAllWithInclude([obj1], 'child.grandchild');
+    assert.equal(obj1.get('child').get('grandchild').get('field'), 'isGrandchild');
+
+    const obj2 = TestObject.createWithoutData(parent.id);
+    await Parse.Object.fetchAllWithInclude([obj2], ['child.grandchild']);
+    assert.equal(obj2.get('child').get('grandchild').get('field'), 'isGrandchild');
+
+    const obj3 = TestObject.createWithoutData(parent.id);
+    await Parse.Object.fetchAllWithInclude([obj3], [ ['child.grandchild'] ]);
+    assert.equal(obj3.get('child').get('grandchild').get('field'), 'isGrandchild');
+  });
+
   it('fires errors when readonly attributes are changed', (done) => {
     let LimitedObject = Parse.Object.extend('LimitedObject');
     LimitedObject.readOnlyAttributes = function() {

integration/test/ParseQueryTest.js

@@ -196,6 +196,53 @@ describe('Parse Query', () => {
     });
   });
 
+  it('can do containedBy queries with numbers', async () => {
+    const NumberSet = Parse.Object.extend('NumberSet');
+    const objectsList = [];
+    objectsList.push(new NumberSet({ numbers: [0, 1, 2] }));
+    objectsList.push(new NumberSet({ numbers: [2, 0] }));
+    objectsList.push(new NumberSet({ numbers: [1, 2, 3, 4] }));
+
+    await Parse.Object.saveAll(objectsList);
+
+    const query = new Parse.Query(NumberSet);
+    query.containedBy('numbers', [1, 2, 3, 4, 5]);
+    const results = await query.find();
+    assert.equal(results.length, 1);
+  });
+
+  it('can do containedBy queries with pointer', async () => {
+    const objects = Array.from(Array(10).keys()).map((idx) => {
+      const obj = new Parse.Object('Object');
+      obj.set('key', idx);
+      return obj;
+    });
+
+    const parent1 = new Parse.Object('Parent');
+    const parent2 = new Parse.Object('Parent');
+    const parent3 = new Parse.Object('Parent');
+
+    await Parse.Object.saveAll(objects);
+
+    // [0, 1, 2]
+    parent1.set('objects', objects.slice(0, 3));
+
+    const shift = objects.shift();
+    // [2, 0]
+    parent2.set('objects', [objects[1], shift]);
+
+    // [1, 2, 3, 4]
+    parent3.set('objects', objects.slice(1, 4));
+
+    await Parse.Object.saveAll([parent1, parent2, parent3]);
+    const query = new Parse.Query('Parent');
+    query.containedBy('objects', objects);
+    const results = await query.find();
+
+    assert.equal(results.length, 1);
+    assert.equal(results[0].id, parent3.id);
+  });
+
   it('can do equalTo queries', (done) => {
     let query = new Parse.Query('BoxedNumber');
     query.equalTo('number', 3);
@@ -1022,6 +1069,50 @@ describe('Parse Query', () => {
     });
   });
 
+  it('can includeAll nested objects', async () => {
+    const child1 = new TestObject({ foo: 'bar' });
+    const child2 = new TestObject({ foo: 'baz' });
+    const child3 = new TestObject({ foo: 'bin' });
+    const parent = new Parse.Object('Container');
+    parent.set('child1', child1);
+    parent.set('child2', child2);
+    parent.set('child3', child3);
+    await Parse.Object.saveAll([child1, child2, child3, parent]);
+
+    const query = new Parse.Query('Container');
+    query.equalTo('objectId', parent.id);
+    query.includeAll();
+
+    const results = await query.find();
+
+    assert.equal(results.length, 1);
+    const parentAgain = results[0];
+    assert.equal(parentAgain.get('child1').get('foo'), 'bar');
+    assert.equal(parentAgain.get('child2').get('foo'), 'baz');
+    assert.equal(parentAgain.get('child3').get('foo'), 'bin');
+  });
+
+  it('can includeAll nested objects in .each', async () => {
+    const child1 = new TestObject({ foo: 'bar' });
+    const child2 = new TestObject({ foo: 'baz' });
+    const child3 = new TestObject({ foo: 'bin' });
+    const parent = new Parse.Object('Container');
+    parent.set('child1', child1);
+    parent.set('child2', child2);
+    parent.set('child3', child3);
+    await Parse.Object.saveAll([child1, child2, child3, parent]);
+
+    const query = new Parse.Query('Container');
+    query.equalTo('objectId', parent.id);
+    query.includeAll();
+
+    await query.each((obj) => {
+      assert.equal(obj.get('child1').get('foo'), 'bar');
+      assert.equal(obj.get('child2').get('foo'), 'baz');
+      assert.equal(obj.get('child3').get('foo'), 'bin');
+    });
+  });
+
   it('can include nested objects via array', (done) => {
     let child = new TestObject();
     let parent = new Parse.Object('Container');
@@ -1367,6 +1458,55 @@ describe('Parse Query', () => {
     }).catch(e => console.log(e));
   });
 
+  it('can build NOR queries', async () => {
+    const objects = [];
+    for (let i = 0; i < 10; i += 1) {
+      const obj = new Parse.Object('NORTest');
+      obj.set({ x: i });
+      objects.push(obj);
+    }
+    await Parse.Object.saveAll(objects);
+
+    const q1 = new Parse.Query('NORTest');
+    q1.greaterThan('x', 5);
+    const q2 = new Parse.Query('NORTest');
+    q2.lessThan('x', 3);
+    const norQuery = Parse.Query.nor(q1, q2);
+    const results = await norQuery.find();
+
+    assert.equal(results.length, 3);
+    results.forEach((number) => {
+      assert(number.get('x') >= 3 && number.get('x') <= 5);
+    });
+  });
+
+  it('can build complex NOR queries', async () => {
+    const objects = [];
+    for (let i = 0; i < 10; i += 1) {
+      const child = new Parse.Object('Child');
+      child.set('x', i);
+      const parent = new Parse.Object('Parent');
+      parent.set('child', child);
+      parent.set('y', i);
+      objects.push(parent);
+    }
+    await Parse.Object.saveAll(objects);
+
+    const subQuery = new Parse.Query('Child');
+    subQuery.equalTo('x', 4);
+    const q1 = new Parse.Query('Parent');
+    q1.matchesQuery('child', subQuery);
+    const q2 = new Parse.Query('Parent');
+    q2.equalTo('y', 5);
+    const norQuery = new Parse.Query.nor(q1, q2);
+    const results = await norQuery.find();
+
+    assert.equal(results.length, 8);
+    results.forEach((number) => {
+      assert(number.get('x') !== 4 || number.get('x') !== 5);
+    });
+  });
+
   it('can iterate over results with each', (done) => {
     let items = [];
     for (let i = 0; i < 50; i++) {

integration/test/ParseUserTest.js

@@ -193,6 +193,55 @@ describe('Parse User', () => {
     });
   });
 
+  it('can fetch non-auth user with include', async () => {
+    Parse.User.enableUnsafeCurrentUser();
+
+    const child = new Parse.Object('TestObject');
+    child.set('field', 'test');
+    let user = new Parse.User();
+    user.set('password', 'asdf');
+    user.set('email', '[email protected]');
+    user.set('username', 'zxcv');
+    user.set('child', child);
+    await user.signUp();
+
+    const query = new Parse.Query(Parse.User);
+    const userNotAuthed = await query.get(user.id);
+
+    assert.equal(userNotAuthed.get('child').get('field'), undefined);
+
+    const fetchedUser = await userNotAuthed.fetchWithInclude('child');
+
+    assert.equal(userNotAuthed.get('child').get('field'), 'test');
+    assert.equal(fetchedUser.get('child').get('field'), 'test');
+  });
+
+  it('can fetch auth user with include', async () => {
+    Parse.User.enableUnsafeCurrentUser();
+
+    const child = new Parse.Object('TestObject');
+    child.set('field', 'test');
+    let user = new Parse.User();
+    user.set('password', 'asdf');
+    user.set('email', '[email protected]');
+    user.set('username', 'zxcv');
+    user.set('child', child);
+    await user.signUp();
+
+    user = await Parse.User.logIn('zxcv', 'asdf');
+
+    assert.equal(user.get('child').get('field'), undefined);
+    assert.equal(Parse.User.current().get('child').get('field'), undefined);
+
+    const fetchedUser = await user.fetchWithInclude('child');
+    const current = await Parse.User.currentAsync();
+    
+    assert.equal(user.get('child').get('field'), 'test');
+    assert.equal(current.get('child').get('field'), 'test');
+    assert.equal(fetchedUser.get('child').get('field'), 'test');
+    assert.equal(Parse.User.current().get('child').get('field'), 'test');
+  });
+
   it('can store the current user', (done) => {
     Parse.User.enableUnsafeCurrentUser();
     let user = new Parse.User();

jsdoc-conf.json

@@ -16,7 +16,7 @@
   },
   "opts": {
     "recurse": true,
-    "template": "node_modules/minami",
+    "template": "node_modules/@parse/minami",
     "showInheritedInNav": true,
     "useLongnameInNav": true
   }