Merge branch 'master' into flow-type-storage-adapter

Author: flovilmart

package.json

@@ -30,8 +30,8 @@
     "intersect": "1.0.1",
     "lodash": "4.17.4",
     "lru-cache": "4.1.1",
-    "mime": "2.0.5",
-    "mongodb": "2.2.33",
+    "mime": "2.1.0",
+    "mongodb": "3.0.1",
     "multer": "1.3.0",
     "parse": "1.11.0",
     "pg-promise": "7.3.2",
@@ -61,7 +61,7 @@
     "jasmine": "2.8.0",
     "jasmine-spec-reporter": "^4.1.0",
     "mongodb-runner": "3.6.1",
-    "nodemon": "1.12.1",
+    "nodemon": "1.14.6",
     "nyc": "^11.0.2",
     "request-promise": "4.2.2"
   },

spec/ParseQuery.Aggregate.spec.js

@@ -392,6 +392,23 @@ describe('Parse.Query Aggregate testing', () => {
       }).catch(done.fail);
   });
 
+  it('distinct pointer', (done) => {
+    const pointer1 = new TestObject();
+    const pointer2 = new TestObject();
+    const obj1 = new TestObject({ pointer: pointer1 });
+    const obj2 = new TestObject({ pointer: pointer2 });
+    const obj3 = new TestObject({ pointer: pointer1 });
+    Parse.Object.saveAll([pointer1, pointer2, obj1, obj2, obj3]).then(() => {
+      const query = new Parse.Query(TestObject);
+      return query.distinct('pointer');
+    }).then((results) => {
+      expect(results.length).toEqual(2);
+      expect(results.some(result => result.objectId === pointer1.id)).toEqual(true);
+      expect(results.some(result => result.objectId === pointer2.id)).toEqual(true);
+      done();
+    });
+  });
+
   it('distinct class does not exist return empty', (done) => {
     const options = Object.assign({}, masterKeyOptions, {
       body: { distinct: 'unknown' }

src/Adapters/Files/GridStoreAdapter.js

@@ -22,15 +22,16 @@ export class GridStoreAdapter extends FilesAdapter {
 
   _connect() {
     if (!this._connectionPromise) {
-      this._connectionPromise = MongoClient.connect(this._databaseURI);
+      this._connectionPromise = MongoClient.connect(this._databaseURI)
+        .then((client) => client.db(client.s.options.dbName));
     }
     return this._connectionPromise;
   }
 
   // For a given config object, filename, and data, store a file
   // Returns a promise
   createFile(filename: string, data) {
-    return this._connect().then(database => {
+    return this._connect().then((database) => {
       const gridStore = new GridStore(database, filename, 'w');
       return gridStore.open();
     }).then(gridStore => {

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -16,6 +16,7 @@ import {
   transformKey,
   transformWhere,
   transformUpdate,
+  transformPointerString,
 } from './MongoTransform';
 // @flow-disable-next
 import Parse                 from 'parse/node';
@@ -132,7 +133,12 @@ export class MongoStorageAdapter implements StorageAdapter {
     // encoded
     const encodedUri = formatUrl(parseUrl(this._uri));
 
-    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(database => {
+    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(client => {
+      // Starting mongoDB 3.0, the MongoClient.connect don't return a DB anymore but a client
+      // Fortunately, we can get back the options and use them to select the proper DB.
+      // https://github.com/mongodb/node-mongodb-native/blob/2c35d76f08574225b8db02d7bef687123e6bb018/lib/mongo_client.js#L885
+      const options = client.s.options;
+      const database = client.db(options.dbName);
       if (!database) {
         delete this.connectionPromise;
         return;
@@ -143,6 +149,7 @@ export class MongoStorageAdapter implements StorageAdapter {
       database.on('close', () => {
         delete this.connectionPromise;
       });
+      this.client = client;
       this.database = database;
     }).catch((err) => {
       delete this.connectionPromise;
@@ -153,10 +160,10 @@ export class MongoStorageAdapter implements StorageAdapter {
   }
 
   handleShutdown() {
-    if (!this.database) {
+    if (!this.client) {
       return;
     }
-    this.database.close(false);
+    this.client.close(false);
   }
 
   _adaptiveCollection(name: string) {
@@ -491,9 +498,19 @@ export class MongoStorageAdapter implements StorageAdapter {
 
   distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {
     schema = convertParseSchemaToMongoSchema(schema);
+    const isPointerField = schema.fields[fieldName] && schema.fields[fieldName].type === 'Pointer';
+    if (isPointerField) {
+      fieldName = `_p_${fieldName}`
+    }
     return this._adaptiveCollection(className)
       .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)))
-      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)));
+      .then(objects => objects.map(object => {
+        if (isPointerField) {
+          const field = fieldName.substring(3);
+          return transformPointerString(schema, field, object);
+        }
+        return mongoObjectToParseObject(className, object, schema);
+      }));
   }
 
   aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) {
@@ -513,26 +530,28 @@ export class MongoStorageAdapter implements StorageAdapter {
   }
 
   _parseReadPreference(readPreference: ?string): ?string {
-    if (readPreference != null) {
-      switch (readPreference) {
-      case 'PRIMARY':
-        readPreference = ReadPreference.PRIMARY;
-        break;
-      case 'PRIMARY_PREFERRED':
-        readPreference = ReadPreference.PRIMARY_PREFERRED;
-        break;
-      case 'SECONDARY':
-        readPreference = ReadPreference.SECONDARY;
-        break;
-      case 'SECONDARY_PREFERRED':
-        readPreference = ReadPreference.SECONDARY_PREFERRED;
-        break;
-      case 'NEAREST':
-        readPreference = ReadPreference.NEAREST;
-        break;
-      default:
-        throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');
-      }
+    switch (readPreference) {
+    case 'PRIMARY':
+      readPreference = ReadPreference.PRIMARY;
+      break;
+    case 'PRIMARY_PREFERRED':
+      readPreference = ReadPreference.PRIMARY_PREFERRED;
+      break;
+    case 'SECONDARY':
+      readPreference = ReadPreference.SECONDARY;
+      break;
+    case 'SECONDARY_PREFERRED':
+      readPreference = ReadPreference.SECONDARY_PREFERRED;
+      break;
+    case 'NEAREST':
+      readPreference = ReadPreference.NEAREST;
+      break;
+    case undefined:
+      // this is to match existing tests, which were failing as [email protected] don't report readPreference anymore
+      readPreference = ReadPreference.PRIMARY;
+      break;
+    default:
+      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');
     }
     return readPreference;
   }

src/Adapters/Storage/Mongo/MongoTransform.js

@@ -1014,6 +1014,18 @@ const nestedMongoObjectToNestedParseObject = mongoObject => {
   }
 }
 
+const transformPointerString = (schema, field, pointerString) => {
+  const objData = pointerString.split('$');
+  if (objData[0] !== schema.fields[field].targetClass) {
+    throw 'pointer to incorrect className';
+  }
+  return {
+    __type: 'Pointer',
+    className: objData[0],
+    objectId: objData[1]
+  };
+}
+
 // Converts from a mongo-format object to a REST-format object.
 // Does not strip out anything based on a lack of authentication.
 const mongoObjectToParseObject = (className, mongoObject, schema) => {
@@ -1126,15 +1138,7 @@ const mongoObjectToParseObject = (className, mongoObject, schema) => {
           if (mongoObject[key] === null) {
             break;
           }
-          var objData = mongoObject[key].split('$');
-          if (objData[0] !== schema.fields[newKey].targetClass) {
-            throw 'pointer to incorrect className';
-          }
-          restObject[newKey] = {
-            __type: 'Pointer',
-            className: objData[0],
-            objectId: objData[1]
-          };
+          restObject[newKey] = transformPointerString(schema, newKey, mongoObject[key]);
           break;
         } else if (key[0] == '_' && key != '__type') {
           throw ('bad key in untransform: ' + key);
@@ -1345,4 +1349,5 @@ module.exports = {
   mongoObjectToParseObject,
   relativeTimeToDate,
   transformConstraint,
+  transformPointerString,
 };

src/Adapters/Storage/Postgres/PostgresStorageAdapter.js

@@ -9,6 +9,7 @@ import sql              from './sql';
 const PostgresRelationDoesNotExistError = '42P01';
 const PostgresDuplicateRelationError = '42P07';
 const PostgresDuplicateColumnError = '42701';
+const PostgresMissingColumnError = '42703';
 const PostgresDuplicateObjectError = '42710';
 const PostgresUniqueIndexViolationError = '23505';
 const PostgresTransactionAbortedError = '25P02';
@@ -1446,21 +1447,37 @@ export class PostgresStorageAdapter implements StorageAdapter {
     const isArrayField = schema.fields
           && schema.fields[fieldName]
           && schema.fields[fieldName].type === 'Array';
+    const isPointerField = schema.fields
+          && schema.fields[fieldName]
+          && schema.fields[fieldName].type === 'Pointer';
     const values = [field, column, className];
     const where = buildWhereClause({ schema, query, index: 4 });
     values.push(...where.values);
 
     const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : '';
-    let qs = `SELECT DISTINCT ON ($1:raw) $2:raw FROM $3:name ${wherePattern}`;
-    if (isArrayField) {
-      qs = `SELECT distinct jsonb_array_elements($1:raw) as $2:raw FROM $3:name ${wherePattern}`;
-    }
+    const transformer = isArrayField ? 'jsonb_array_elements' : 'ON';
+    const qs = `SELECT DISTINCT ${transformer}($1:raw) $2:raw FROM $3:name ${wherePattern}`;
     debug(qs, values);
     return this._client.any(qs, values)
-      .catch(() => [])
+      .catch((error) => {
+        if (error.code === PostgresMissingColumnError) {
+          return [];
+        }
+        throw error;
+      })
       .then((results) => {
         if (fieldName.indexOf('.') === -1) {
-          return results.map(object => object[field]);
+          results = results.filter((object) => object[field] !== null);
+          return results.map(object => {
+            if (!isPointerField) {
+              return object[field];
+            }
+            return {
+              __type: 'Pointer',
+              className:  schema.fields[fieldName].targetClass,
+              objectId: object[field]
+            };
+          });
         }
         const child = fieldName.split('.')[1];
         return results.map(object => object[column][child]);