Merge pull request #794 from ParsePlatform/nlutsenko.schemasRouter

Completely migrate SchemasRouter to new MongoCollection API.

spec/Schema.spec.js

@@ -188,8 +188,8 @@ describe('Schema', () => {
           foo: {type: 'String'}
         }))
         .catch(error => {
-          expect(error.code).toEqual(Parse.Error.INVALID_CLASS_NAME)
+          expect(error.code).toEqual(Parse.Error.INVALID_CLASS_NAME);
-          expect(error.error).toEqual('class NewClass already exists');
+          expect(error.message).toEqual('Class NewClass already exists.');
           done();
         });
       });
@@ -216,7 +216,7 @@ describe('Schema', () => {
       Promise.all([p1,p2])
       .catch(error => {
         expect(error.code).toEqual(Parse.Error.INVALID_CLASS_NAME);
-        expect(error.error).toEqual('class NewClass already exists');
+        expect(error.message).toEqual('Class NewClass already exists.');
         done();
       });
     });
@@ -561,7 +561,8 @@ describe('Schema', () => {
       .then(() => config.database.collectionExists('_Join:aRelation:HasPointersAndRelations'))
       .then(exists => {
         if (!exists) {
-          fail('Relation collection should exist after save.');
+          fail('Relation collection ' +
+            'should exist after save.');
         }
       })
       .then(() => config.database.loadSchema())

spec/schemas.spec.js

@@ -175,7 +175,7 @@ describe('schemas', () => {
         expect(response.statusCode).toEqual(400);
         expect(body).toEqual({
           code: 103,
-          error: 'class HASALLPOD does not exist',
+          error: 'Class HASALLPOD does not exist.',
         });
         done();
       });
@@ -224,7 +224,7 @@ describe('schemas', () => {
       expect(response.statusCode).toEqual(400);
       expect(body).toEqual({
         code: Parse.Error.INVALID_CLASS_NAME,
-        error: 'class name mismatch between B and A',
+        error: 'Class name mismatch between B and A.',
       });
       done();
     });
@@ -240,7 +240,7 @@ describe('schemas', () => {
       expect(response.statusCode).toEqual(400);
       expect(body).toEqual({
         code: 135,
-        error: 'POST /schemas needs class name',
+        error: 'POST /schemas needs a class name.',
       });
       done();
     })
@@ -267,7 +267,7 @@ describe('schemas', () => {
         expect(response.statusCode).toEqual(400);
         expect(body).toEqual({
           code: Parse.Error.INVALID_CLASS_NAME,
-          error: 'class A already exists',
+          error: 'Class A already exists.'
         });
         done();
       });
@@ -353,7 +353,7 @@ describe('schemas', () => {
     }, (error, response, body) => {
       expect(response.statusCode).toEqual(400);
       expect(body.code).toEqual(Parse.Error.INVALID_CLASS_NAME);
-      expect(body.error).toEqual('class name mismatch between WrongClassName and NewClass');
+      expect(body.error).toEqual('Class name mismatch between WrongClassName and NewClass.');
       done();
     });
   });
@@ -733,7 +733,7 @@ describe('schemas', () => {
             //Expect _SCHEMA entry to be gone.
             expect(response.statusCode).toEqual(400);
             expect(body.code).toEqual(Parse.Error.INVALID_CLASS_NAME);
-            expect(body.error).toEqual('class MyOtherClass does not exist');
+            expect(body.error).toEqual('Class MyOtherClass does not exist.');
             done();
           });
         });

src/Routers/SchemasRouter.js

@@ -8,13 +8,10 @@ import PromiseRouter from '../PromiseRouter';
 import * as middleware from "../middlewares";
 
 function classNameMismatchResponse(bodyClass, pathClass) {
-  return Promise.resolve({
+  throw new Parse.Error(
-    status: 400,
+    Parse.Error.INVALID_CLASS_NAME,
-    response: {
+    `Class name mismatch between ${bodyClass} and ${pathClass}.`
-      code: Parse.Error.INVALID_CLASS_NAME,
+  );
-      error: 'class name mismatch between ' + bodyClass + ' and ' + pathClass,
-    }
-  });
 }
 
 function mongoSchemaAPIResponseFields(schema) {
@@ -45,16 +42,16 @@ function getAllSchemas(req) {
 }
 
 function getOneSchema(req) {
-  return req.config.database.collection('_SCHEMA')
+  const className = req.params.className;
-    .then(coll => coll.findOne({'_id': req.params.className}))
+  return req.config.database.adaptiveCollection('_SCHEMA')
-    .then(schema => ({response: mongoSchemaToSchemaAPIResponse(schema)}))
+    .then(collection => collection.find({ '_id': className }, { limit: 1 }))
-    .catch(() => ({
+    .then(results => {
-      status: 400,
+      if (results.length != 1) {
-      response: {
+        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);
-        code: 103,
-        error: 'class ' + req.params.className + ' does not exist',
       }
-    }));
+      return results[0];
+    })
+    .then(schema => ({ response: mongoSchemaToSchemaAPIResponse(schema) }));
 }
 
 function createSchema(req) {
@@ -63,23 +60,15 @@ function createSchema(req) {
       return classNameMismatchResponse(req.body.className, req.params.className);
     }
   }
-  var className = req.params.className || req.body.className;
+
+  const className = req.params.className || req.body.className;
   if (!className) {
-    return Promise.resolve({
+    throw new Parse.Error(135, `POST ${req.path} needs a class name.`);
-      status: 400,
-      response: {
-        code: 135,
-        error: 'POST ' + req.path + ' needs class name',
-      },
-    });
   }
+
   return req.config.database.loadSchema()
     .then(schema => schema.addClassIfNotExists(className, req.body.fields))
-    .then(result => ({ response: mongoSchemaToSchemaAPIResponse(result) }))
+    .then(result => ({ response: mongoSchemaToSchemaAPIResponse(result) }));
-    .catch(error => ({
-      status: 400,
-      response: error,
-    }));
 }
 
 function modifySchema(req) {

src/Schema.js

@@ -340,29 +340,22 @@ function buildMergedSchemaObject(mongoObject, putRequest) {
 // enabled) before calling this function.
 Schema.prototype.addClassIfNotExists = function(className, fields) {
   if (this.data[className]) {
-    return Promise.reject({
+    throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);
-      code: Parse.Error.INVALID_CLASS_NAME,
-      error: 'class ' + className + ' already exists',
-    });
   }
 
-  var mongoObject = mongoSchemaFromFieldsAndClassName(fields, className);
+  let mongoObject = mongoSchemaFromFieldsAndClassName(fields, className);
-
   if (!mongoObject.result) {
     return Promise.reject(mongoObject);
   }
 
   return this.collection.insertOne(mongoObject.result)
-  .then(result => result.ops[0])
+    .then(result => result.ops[0])
-  .catch(error => {
+    .catch(error => {
-    if (error.code === 11000) { //Mongo's duplicate key error
+      if (error.code === 11000) { //Mongo's duplicate key error
-      return Promise.reject({
+        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);
-        code: Parse.Error.INVALID_CLASS_NAME,
+      }
-        error: 'class ' + className + ' already exists',
+      return Promise.reject(error);
-      });
+    });
-    }
-    return Promise.reject(error);
-  });
 };
 
 // Returns a promise that resolves successfully to the new schema