Merge remote-tracking branch 'upstream/master' into test-configurations

src/Adapters/Files/S3Adapter.js

@@ -6,7 +6,6 @@ import * as AWS from 'aws-sdk';
 import { FilesAdapter } from './FilesAdapter';
 
 const DEFAULT_S3_REGION = "us-east-1";
-const DEFAULT_S3_BUCKET = "parse-files";
 
 export class S3Adapter extends FilesAdapter {
   // Creates an S3 session.
@@ -15,8 +14,8 @@ export class S3Adapter extends FilesAdapter {
   constructor(
     accessKey,
     secretKey,
+    bucket,
     { region = DEFAULT_S3_REGION,
-      bucket = DEFAULT_S3_BUCKET,
       bucketPrefix = '',
       directAccess = false } = {}
   ) {

src/ExportAdapter.js

@@ -306,7 +306,8 @@ ExportAdapter.prototype.destroy = function(className, query, options = {}) {
 
     return coll.remove(mongoWhere);
   }).then((resp) => {
-    if (resp.result.n === 0) {
+    //Check _Session to avoid changing password failed without any session.
+    if (resp.result.n === 0 && className !== "_Session") {
       return Promise.reject(
         new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,
                         'Object not found.'));

src/Schema.js

@@ -521,7 +521,7 @@ Schema.prototype.deleteField = function(fieldName, className, database, prefix)
         });
       }
 
-      if (schema.data[className][fieldName].startsWith('relation')) {
+      if (schema.data[className][fieldName].startsWith('relation<')) {
         //For relations, drop the _Join table
         return database.dropCollection(prefix + '_Join:' + fieldName + ':' + className)
         //Save the _SCHEMA object
@@ -714,6 +714,7 @@ function getObjectType(obj) {
 module.exports = {
   load: load,
   classNameIsValid: classNameIsValid,
+  invalidClassNameMessage: invalidClassNameMessage,
   mongoSchemaFromFieldsAndClassName: mongoSchemaFromFieldsAndClassName,
   schemaAPITypeToMongoFieldType: schemaAPITypeToMongoFieldType,
   buildMergedSchemaObject: buildMergedSchemaObject,

src/functions.js

@@ -10,10 +10,15 @@ var router = new PromiseRouter();
 function handleCloudFunction(req) {
   if (Parse.Cloud.Functions[req.params.functionName]) {
 
-    const params = Object.assign({}, req.body, req.query);
-    
+    var request = {
+      params: Object.assign({}, req.body, req.query),
+      master: req.auth && req.auth.isMaster,
+      user: req.auth && req.auth.user,
+      installationId: req.info.installationId
+    };
+
     if (Parse.Cloud.Validators[req.params.functionName]) {
-      var result = Parse.Cloud.Validators[req.params.functionName](params);
+      var result = Parse.Cloud.Validators[req.params.functionName](request);
       if (!result) {
         throw new Parse.Error(Parse.Error.SCRIPT_FAILED, 'Validation failed.');
       }
@@ -21,12 +26,6 @@ function handleCloudFunction(req) {
 
     return new Promise(function (resolve, reject) {
       var response = createResponseObject(resolve, reject);
-      var request = {
-        params: params,
-        master: req.auth && req.auth.isMaster,
-        user: req.auth && req.auth.user,
-        installationId: req.info.installationId
-      };
       Parse.Cloud.Functions[req.params.functionName](request, response);
     });
   } else {

src/middlewares.js

@@ -26,7 +26,7 @@ function handleParseHeaders(req, res, next) {
     restAPIKey: req.get('X-Parse-REST-API-Key')
   };
 
-  if (req.body && req.body._noBody) {
+  if (req.body) {
     // Unity SDK sends a _noBody key which needs to be removed.
     // Unclear at this point if action needs to be taken.
     delete req.body._noBody;

src/schemas.js

@@ -183,10 +183,95 @@ function modifySchema(req) {
   });
 }
 
+// A helper function that removes all join tables for a schema. Returns a promise.
+var removeJoinTables = (database, prefix, mongoSchema) => {
+  return Promise.all(Object.keys(mongoSchema)
+    .filter(field => mongoSchema[field].startsWith('relation<'))
+    .map(field => {
+      var joinCollectionName = prefix + '_Join:' + field + ':' + mongoSchema._id;
+      return new Promise((resolve, reject) => {
+        database.dropCollection(joinCollectionName, (err, results) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        })
+      });
+    })
+  );
+};
+
+function deleteSchema(req) {
+  if (!req.auth.isMaster) {
+    return masterKeyRequiredResponse();
+  }
+
+  if (!Schema.classNameIsValid(req.params.className)) {
+    return Promise.resolve({
+      status: 400,
+      response: {
+        code: Parse.Error.INVALID_CLASS_NAME,
+        error: Schema.invalidClassNameMessage(req.params.className),
+      }
+    });
+  }
+
+  return req.config.database.collection(req.params.className)
+  .then(coll => new Promise((resolve, reject) => {
+    coll.count((err, count) => {
+      if (err) {
+        reject(err);
+      } else if (count > 0) {
+        resolve({
+          status: 400,
+          response: {
+            code: 255,
+            error: 'class ' + req.params.className + ' not empty, contains ' + count + ' objects, cannot drop schema',
+          }
+        });
+      } else {
+        coll.drop((err, reply) => {
+          if (err) {
+            reject(err);
+          } else {
+            // We've dropped the collection now, so delete the item from _SCHEMA
+            // and clear the _Join collections
+            req.config.database.collection('_SCHEMA')
+            .then(coll => new Promise((resolve, reject) => {
+              coll.findAndRemove({ _id: req.params.className }, [], (err, doc) => {
+                if (err) {
+                  reject(err);
+                } else if (doc.value === null) {
+                  //tried to delete non-existant class
+                  resolve({ response: {}});
+                } else {
+                  removeJoinTables(req.config.database.db, req.config.database.collectionPrefix, doc.value)
+                  .then(resolve, reject);
+                }
+              });
+            }))
+            .then(resolve.bind(undefined, {response: {}}), reject);
+          }
+        });
+      }
+    });
+  }))
+  .catch(error => {
+    if (error.message == 'ns not found') {
+      // If they try to delete a non-existant class, thats fine, just let them.
+      return Promise.resolve({ response: {} });
+    } else {
+      return Promise.reject(error);
+    }
+  });
+}
+
 router.route('GET', '/schemas', getAllSchemas);
 router.route('GET', '/schemas/:className', getOneSchema);
 router.route('POST', '/schemas', createSchema);
 router.route('POST', '/schemas/:className', createSchema);
 router.route('PUT', '/schemas/:className', modifySchema);
+router.route('DELETE', '/schemas/:className', deleteSchema);
 
 module.exports = router;