Finish implementation of PUT /schemas/:className

src/Schema.js

@@ -116,7 +116,7 @@ function schemaAPITypeToMongoFieldType(type) {
       return invalidJsonError;
     } else if (!classNameIsValid(type.targetClass)) {
       return { error: invalidClassNameMessage(type.targetClass), code: Parse.Error.INVALID_CLASS_NAME };
-    } else  {
+    } else {
       return { result: '*' + type.targetClass };
     }
   }
@@ -200,6 +200,114 @@ Schema.prototype.reload = function() {
   return load(this.collection);
 };
 
+// Returns { code, error } if invalid, or { result }, an object
+// suitable for inserting into _SCHEMA collection, otherwise
+function mongoSchemaFromFieldsAndClassName(fields, className) {
+  if (!classNameIsValid(className)) {
+    return {
+      code: Parse.Error.INVALID_CLASS_NAME,
+      error: invalidClassNameMessage(className),
+    };
+  }
+
+  for (var fieldName in fields) {
+    if (!fieldNameIsValid(fieldName)) {
+      return {
+        code: Parse.Error.INVALID_KEY_NAME,
+        error: 'invalid field name: ' + fieldName,
+      };
+    }
+    if (!fieldNameIsValidForClass(fieldName, className)) {
+      return {
+        code: 136,
+        error: 'field ' + fieldName + ' cannot be added',
+      };
+    }
+  }
+
+  var mongoObject = {
+    _id: className,
+    objectId: 'string',
+    updatedAt: 'string',
+    createdAt: 'string'
+  };
+
+  for (var fieldName in defaultColumns[className]) {
+    var validatedField = schemaAPITypeToMongoFieldType(defaultColumns[className][fieldName]);
+    if (!validatedField.result) {
+      return validatedField;
+    }
+    mongoObject[fieldName] = validatedField.result;
+  }
+
+  for (var fieldName in fields) {
+    var validatedField = schemaAPITypeToMongoFieldType(fields[fieldName]);
+    if (!validatedField.result) {
+      return validatedField;
+    }
+    mongoObject[fieldName] = validatedField.result;
+  }
+
+  var geoPoints = Object.keys(mongoObject).filter(key => mongoObject[key] === 'geopoint');
+  if (geoPoints.length > 1) {
+    return {
+      code: Parse.Error.INCORRECT_TYPE,
+      error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.',
+    };
+  }
+
+  return { result: mongoObject };
+}
+
+function mongoFieldTypeToSchemaAPIType(type) {
+  if (type[0] === '*') {
+    return {
+      type: 'Pointer',
+      targetClass: type.slice(1),
+    };
+  }
+  if (type.startsWith('relation<')) {
+    return {
+      type: 'Relation',
+      targetClass: type.slice('relation<'.length, type.length - 1),
+    };
+  }
+  switch (type) {
+    case 'number':   return {type: 'Number'};
+    case 'string':   return {type: 'String'};
+    case 'boolean':  return {type: 'Boolean'};
+    case 'date':     return {type: 'Date'};
+    case 'map':
+    case 'object':   return {type: 'Object'};
+    case 'array':    return {type: 'Array'};
+    case 'geopoint': return {type: 'GeoPoint'};
+    case 'file':     return {type: 'File'};
+  }
+}
+
+// Builds a new schema (in schema API response format) out of an
+// existing mongo schema + a schemas API put request. This response
+// does not include the default fields, as it is intended to be passed
+// to mongoSchemaFromFieldsAndClassName. No validation is done here, it
+// is done in mongoSchemaFromFieldsAndClassName.
+function buildMergedSchemaObject(mongoObject, putRequest) {
+  var newSchema = {};
+  for (var oldField in mongoObject) {
+    if (oldField !== '_id' && oldField !== 'ACL' &&  oldField !== 'updatedAt' && oldField !== 'createdAt' && oldField !== 'objectId') {
+      var fieldIsDeleted = putRequest[oldField] && putRequest[oldField].__op === 'Delete'
+      if (!fieldIsDeleted) {
+        newSchema[oldField] = mongoFieldTypeToSchemaAPIType(mongoObject[oldField]);
+      }
+    }
+  }
+  for (var newField in putRequest) {
+    if (newField !== 'objectId' && putRequest[newField].__op !== 'Delete') {
+      newSchema[newField] = putRequest[newField];
+    }
+  }
+  return newSchema;
+}
+
 // Create a new class that includes the three default fields.
 // ACL is an implicit column that does not get an entry in the
 // _SCHEMAS database. Returns a promise that resolves with the
@@ -215,58 +323,13 @@ Schema.prototype.addClassIfNotExists = function(className, fields) {
     });
   }
 
-  if (!classNameIsValid(className)) {
-    return Promise.reject({
-      code: Parse.Error.INVALID_CLASS_NAME,
-      error: invalidClassNameMessage(className),
-    });
-  }
-  for (var fieldName in fields) {
-    if (!fieldNameIsValid(fieldName)) {
-      return Promise.reject({
-        code: Parse.Error.INVALID_KEY_NAME,
-        error: 'invalid field name: ' + fieldName,
-      });
-    }
-    if (!fieldNameIsValidForClass(fieldName, className)) {
-      return Promise.reject({
-        code: 136,
-        error: 'field ' + fieldName + ' cannot be added',
-      });
-    }
+  var mongoObject = mongoSchemaFromFieldsAndClassName(fields, className);
+
+  if (!mongoObject.result) {
+    return Promise.reject(mongoObject);
   }
 
-  var mongoObject = {
-    _id: className,
-    objectId: 'string',
-    updatedAt: 'string',
-    createdAt: 'string'
-  };
-  for (var fieldName in defaultColumns[className]) {
-    var validatedField = schemaAPITypeToMongoFieldType(defaultColumns[className][fieldName]);
-    if (validatedField.code) {
-      return Promise.reject(validatedField);
-    }
-    mongoObject[fieldName] = validatedField.result;
-  }
-
-  for (var fieldName in fields) {
-    var validatedField = schemaAPITypeToMongoFieldType(fields[fieldName]);
-    if (validatedField.code) {
-      return Promise.reject(validatedField);
-    }
-    mongoObject[fieldName] = validatedField.result;
-  }
-
-  var geoPoints = Object.keys(mongoObject).filter(key => mongoObject[key] === 'geopoint');
-  if (geoPoints.length > 1) {
-    return Promise.reject({
-      code: Parse.Error.INCORRECT_TYPE,
-      error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.',
-    });
-  }
-
-  return this.collection.insertOne(mongoObject)
+  return this.collection.insertOne(mongoObject.result)
   .then(result => result.ops[0])
   .catch(error => {
     if (error.code === 11000) { //Mongo's duplicate key error
@@ -651,4 +714,8 @@ function getObjectType(obj) {
 module.exports = {
   load: load,
   classNameIsValid: classNameIsValid,
+  mongoSchemaFromFieldsAndClassName: mongoSchemaFromFieldsAndClassName,
+  schemaAPITypeToMongoFieldType: schemaAPITypeToMongoFieldType,
+  buildMergedSchemaObject: buildMergedSchemaObject,
+  mongoFieldTypeToSchemaAPIType: mongoFieldTypeToSchemaAPIType,
 };