@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Storage/Mongo/MongoTransform.js

@@ -0,0 +1,1397 @@
+"use strict";
+
+var _logger = _interopRequireDefault(require("../../../logger"));
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var mongodb = require('mongodb');
+var Parse = require('parse/node').Parse;
+const Utils = require('../../../Utils');
+const transformKey = (className, fieldName, schema) => {
+  // Check if the schema is known since it's a built-in field.
+  switch (fieldName) {
+    case 'objectId':
+      return '_id';
+    case 'createdAt':
+      return '_created_at';
+    case 'updatedAt':
+      return '_updated_at';
+    case 'sessionToken':
+      return '_session_token';
+    case 'lastUsed':
+      return '_last_used';
+    case 'timesUsed':
+      return 'times_used';
+  }
+  if (schema.fields[fieldName] && schema.fields[fieldName].__type == 'Pointer') {
+    fieldName = '_p_' + fieldName;
+  } else if (schema.fields[fieldName] && schema.fields[fieldName].type == 'Pointer') {
+    fieldName = '_p_' + fieldName;
+  }
+  return fieldName;
+};
+const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSchema) => {
+  // Check if the schema is known since it's a built-in field.
+  var key = restKey;
+  var timeField = false;
+  switch (key) {
+    case 'objectId':
+    case '_id':
+      if (['_GlobalConfig', '_GraphQLConfig'].includes(className)) {
+        return {
+          key: key,
+          value: parseInt(restValue)
+        };
+      }
+      key = '_id';
+      break;
+    case 'createdAt':
+    case '_created_at':
+      key = '_created_at';
+      timeField = true;
+      break;
+    case 'updatedAt':
+    case '_updated_at':
+      key = '_updated_at';
+      timeField = true;
+      break;
+    case 'sessionToken':
+    case '_session_token':
+      key = '_session_token';
+      break;
+    case 'expiresAt':
+    case '_expiresAt':
+      key = 'expiresAt';
+      timeField = true;
+      break;
+    case '_email_verify_token_expires_at':
+      key = '_email_verify_token_expires_at';
+      timeField = true;
+      break;
+    case '_account_lockout_expires_at':
+      key = '_account_lockout_expires_at';
+      timeField = true;
+      break;
+    case '_failed_login_count':
+      key = '_failed_login_count';
+      break;
+    case '_perishable_token_expires_at':
+      key = '_perishable_token_expires_at';
+      timeField = true;
+      break;
+    case '_password_changed_at':
+      key = '_password_changed_at';
+      timeField = true;
+      break;
+    case '_rperm':
+    case '_wperm':
+      return {
+        key: key,
+        value: restValue
+      };
+    case 'lastUsed':
+    case '_last_used':
+      key = '_last_used';
+      timeField = true;
+      break;
+    case 'timesUsed':
+    case 'times_used':
+      key = 'times_used';
+      timeField = true;
+      break;
+  }
+  if (parseFormatSchema.fields[key] && parseFormatSchema.fields[key].type === 'Pointer' || !key.includes('.') && !parseFormatSchema.fields[key] && restValue && restValue.__type == 'Pointer' // Do not use the _p_ prefix for pointers inside nested documents
+  ) {
+    key = '_p_' + key;
+  }
+
+  // Handle atomic values
+  var value = transformTopLevelAtom(restValue);
+  if (value !== CannotTransform) {
+    if (timeField && typeof value === 'string') {
+      value = new Date(value);
+    }
+    if (restKey.indexOf('.') > 0) {
+      return {
+        key,
+        value: restValue
+      };
+    }
+    return {
+      key,
+      value
+    };
+  }
+
+  // Handle arrays
+  if (Array.isArray(restValue)) {
+    value = restValue.map(transformInteriorValue);
+    return {
+      key,
+      value
+    };
+  }
+
+  // Handle update operators
+  if (typeof restValue === 'object' && '__op' in restValue) {
+    return {
+      key,
+      value: transformUpdateOperator(restValue, false)
+    };
+  }
+
+  // Handle normal objects by recursing
+  value = mapValues(restValue, transformInteriorValue);
+  return {
+    key,
+    value
+  };
+};
+const isRegex = value => {
+  return value && Utils.isRegExp(value);
+};
+const isStartsWithRegex = value => {
+  if (!isRegex(value)) {
+    return false;
+  }
+  const matches = value.toString().match(/\/\^\\Q.*\\E\//);
+  return !!matches;
+};
+const isAllValuesRegexOrNone = values => {
+  if (!values || !Array.isArray(values) || values.length === 0) {
+    return true;
+  }
+  const firstValuesIsRegex = isStartsWithRegex(values[0]);
+  if (values.length === 1) {
+    return firstValuesIsRegex;
+  }
+  for (let i = 1, length = values.length; i < length; ++i) {
+    if (firstValuesIsRegex !== isStartsWithRegex(values[i])) {
+      return false;
+    }
+  }
+  return true;
+};
+const isAnyValueRegex = values => {
+  return values.some(function (value) {
+    return isRegex(value);
+  });
+};
+const transformInteriorValue = restValue => {
+  if (restValue !== null && typeof restValue === 'object' && Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))) {
+    throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters");
+  }
+  // Handle atomic values
+  var value = transformInteriorAtom(restValue);
+  if (value !== CannotTransform) {
+    if (value && typeof value === 'object') {
+      if (Utils.isDate(value)) {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        value = value.map(transformInteriorValue);
+      } else {
+        value = mapValues(value, transformInteriorValue);
+      }
+    }
+    return value;
+  }
+
+  // Handle arrays
+  if (Array.isArray(restValue)) {
+    return restValue.map(transformInteriorValue);
+  }
+
+  // Handle update operators
+  if (typeof restValue === 'object' && '__op' in restValue) {
+    return transformUpdateOperator(restValue, true);
+  }
+
+  // Handle normal objects by recursing
+  return mapValues(restValue, transformInteriorValue);
+};
+const valueAsDate = value => {
+  if (typeof value === 'string') {
+    return new Date(value);
+  } else if (Utils.isDate(value)) {
+    return value;
+  }
+  return false;
+};
+function transformQueryKeyValue(className, key, value, schema, count = false) {
+  switch (key) {
+    case 'createdAt':
+      if (valueAsDate(value)) {
+        return {
+          key: '_created_at',
+          value: valueAsDate(value)
+        };
+      }
+      key = '_created_at';
+      break;
+    case 'updatedAt':
+      if (valueAsDate(value)) {
+        return {
+          key: '_updated_at',
+          value: valueAsDate(value)
+        };
+      }
+      key = '_updated_at';
+      break;
+    case 'expiresAt':
+      if (valueAsDate(value)) {
+        return {
+          key: 'expiresAt',
+          value: valueAsDate(value)
+        };
+      }
+      break;
+    case '_email_verify_token_expires_at':
+      if (valueAsDate(value)) {
+        return {
+          key: '_email_verify_token_expires_at',
+          value: valueAsDate(value)
+        };
+      }
+      break;
+    case 'objectId':
+      {
+        if (['_GlobalConfig', '_GraphQLConfig'].includes(className)) {
+          value = parseInt(value);
+        }
+        return {
+          key: '_id',
+          value
+        };
+      }
+    case '_account_lockout_expires_at':
+      if (valueAsDate(value)) {
+        return {
+          key: '_account_lockout_expires_at',
+          value: valueAsDate(value)
+        };
+      }
+      break;
+    case '_failed_login_count':
+      return {
+        key,
+        value
+      };
+    case 'sessionToken':
+      return {
+        key: '_session_token',
+        value
+      };
+    case '_perishable_token_expires_at':
+      if (valueAsDate(value)) {
+        return {
+          key: '_perishable_token_expires_at',
+          value: valueAsDate(value)
+        };
+      }
+      break;
+    case '_password_changed_at':
+      if (valueAsDate(value)) {
+        return {
+          key: '_password_changed_at',
+          value: valueAsDate(value)
+        };
+      }
+      break;
+    case '_rperm':
+    case '_wperm':
+    case '_perishable_token':
+    case '_email_verify_token':
+      return {
+        key,
+        value
+      };
+    case '$or':
+    case '$and':
+    case '$nor':
+      return {
+        key: key,
+        value: value.map(subQuery => transformWhere(className, subQuery, schema, count))
+      };
+    case 'lastUsed':
+      if (valueAsDate(value)) {
+        return {
+          key: '_last_used',
+          value: valueAsDate(value)
+        };
+      }
+      key = '_last_used';
+      break;
+    case 'timesUsed':
+      return {
+        key: 'times_used',
+        value: value
+      };
+    default:
+      {
+        // Other auth data
+        const authDataMatch = key.match(/^authData\.([a-zA-Z0-9_]+)(\.(.+))?$/);
+        if (authDataMatch && className === '_User') {
+          const provider = authDataMatch[1];
+          const subField = authDataMatch[3];
+          return {
+            key: `_auth_data_${provider}${subField ? `.${subField}` : ''}`,
+            value
+          };
+        }
+      }
+  }
+  const expectedTypeIsArray = schema && schema.fields[key] && schema.fields[key].type === 'Array';
+  const expectedTypeIsPointer = schema && schema.fields[key] && schema.fields[key].type === 'Pointer';
+  const field = schema && schema.fields[key];
+  if (expectedTypeIsPointer || !schema && !key.includes('.') && value && value.__type === 'Pointer') {
+    key = '_p_' + key;
+  }
+
+  // Handle query constraints
+  const transformedConstraint = transformConstraint(value, field, key, count);
+  if (transformedConstraint !== CannotTransform) {
+    if (transformedConstraint.$text) {
+      return {
+        key: '$text',
+        value: transformedConstraint.$text
+      };
+    }
+    if (transformedConstraint.$elemMatch) {
+      return {
+        key: '$nor',
+        value: [{
+          [key]: transformedConstraint
+        }]
+      };
+    }
+    return {
+      key,
+      value: transformedConstraint
+    };
+  }
+  if (expectedTypeIsArray && !Array.isArray(value)) {
+    return {
+      key,
+      value: {
+        $all: [transformInteriorAtom(value)]
+      }
+    };
+  }
+
+  // Handle atomic values
+  const transformRes = key.includes('.') ? transformInteriorAtom(value) : transformTopLevelAtom(value);
+  if (transformRes !== CannotTransform) {
+    return {
+      key,
+      value: transformRes
+    };
+  } else {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, `You cannot use ${value} as a query parameter.`);
+  }
+}
+
+// Main exposed method to help run queries.
+// restWhere is the "where" clause in REST API form.
+// Returns the mongo form of the query.
+function transformWhere(className, restWhere, schema, count = false) {
+  const mongoWhere = {};
+  for (const restKey in restWhere) {
+    const out = transformQueryKeyValue(className, restKey, restWhere[restKey], schema, count);
+    mongoWhere[out.key] = out.value;
+  }
+  return mongoWhere;
+}
+const parseObjectKeyValueToMongoObjectKeyValue = (restKey, restValue, schema) => {
+  // Check if the schema is known since it's a built-in field.
+  let transformedValue;
+  let coercedToDate;
+  switch (restKey) {
+    case 'objectId':
+      return {
+        key: '_id',
+        value: restValue
+      };
+    case 'expiresAt':
+      transformedValue = transformTopLevelAtom(restValue);
+      coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;
+      return {
+        key: 'expiresAt',
+        value: coercedToDate
+      };
+    case '_email_verify_token_expires_at':
+      transformedValue = transformTopLevelAtom(restValue);
+      coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;
+      return {
+        key: '_email_verify_token_expires_at',
+        value: coercedToDate
+      };
+    case '_account_lockout_expires_at':
+      transformedValue = transformTopLevelAtom(restValue);
+      coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;
+      return {
+        key: '_account_lockout_expires_at',
+        value: coercedToDate
+      };
+    case '_perishable_token_expires_at':
+      transformedValue = transformTopLevelAtom(restValue);
+      coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;
+      return {
+        key: '_perishable_token_expires_at',
+        value: coercedToDate
+      };
+    case '_password_changed_at':
+      transformedValue = transformTopLevelAtom(restValue);
+      coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;
+      return {
+        key: '_password_changed_at',
+        value: coercedToDate
+      };
+    case '_failed_login_count':
+    case '_rperm':
+    case '_wperm':
+    case '_email_verify_token':
+    case '_hashed_password':
+    case '_perishable_token':
+      return {
+        key: restKey,
+        value: restValue
+      };
+    case 'sessionToken':
+      return {
+        key: '_session_token',
+        value: restValue
+      };
+    default:
+      // Auth data should have been transformed already
+      if (restKey.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) {
+        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'can only query on ' + restKey);
+      }
+      // Trust that the auth data has been transformed and save it directly
+      if (restKey.match(/^_auth_data_[a-zA-Z0-9_]+$/)) {
+        return {
+          key: restKey,
+          value: restValue
+        };
+      }
+  }
+  //skip straight to transformTopLevelAtom for Bytes, they don't show up in the schema for some reason
+  if (restValue && restValue.__type !== 'Bytes') {
+    //Note: We may not know the type of a field here, as the user could be saving (null) to a field
+    //That never existed before, meaning we can't infer the type.
+    if (schema.fields[restKey] && schema.fields[restKey].type == 'Pointer' || restValue.__type == 'Pointer') {
+      restKey = '_p_' + restKey;
+    }
+  }
+
+  // Handle atomic values
+  var value = transformTopLevelAtom(restValue);
+  if (value !== CannotTransform) {
+    return {
+      key: restKey,
+      value: value
+    };
+  }
+
+  // ACLs are handled before this method is called
+  // If an ACL key still exists here, something is wrong.
+  if (restKey === 'ACL') {
+    throw 'There was a problem transforming an ACL.';
+  }
+
+  // Handle arrays
+  if (Array.isArray(restValue)) {
+    value = restValue.map(transformInteriorValue);
+    return {
+      key: restKey,
+      value: value
+    };
+  }
+
+  // Handle normal objects by recursing
+  if (Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))) {
+    throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters");
+  }
+  value = mapValues(restValue, transformInteriorValue);
+  return {
+    key: restKey,
+    value
+  };
+};
+const parseObjectToMongoObjectForCreate = (className, restCreate, schema) => {
+  restCreate = addLegacyACL(restCreate);
+  const mongoCreate = {};
+  for (const restKey in restCreate) {
+    if (restCreate[restKey] && restCreate[restKey].__type === 'Relation') {
+      continue;
+    }
+    const {
+      key,
+      value
+    } = parseObjectKeyValueToMongoObjectKeyValue(restKey, restCreate[restKey], schema);
+    if (value !== undefined) {
+      mongoCreate[key] = value;
+    }
+  }
+
+  // Use the legacy mongo format for createdAt and updatedAt
+  if (mongoCreate.createdAt) {
+    mongoCreate._created_at = new Date(mongoCreate.createdAt.iso || mongoCreate.createdAt);
+    delete mongoCreate.createdAt;
+  }
+  if (mongoCreate.updatedAt) {
+    mongoCreate._updated_at = new Date(mongoCreate.updatedAt.iso || mongoCreate.updatedAt);
+    delete mongoCreate.updatedAt;
+  }
+  return mongoCreate;
+};
+
+// Main exposed method to help update old objects.
+const transformUpdate = (className, restUpdate, parseFormatSchema) => {
+  const mongoUpdate = {};
+  const acl = addLegacyACL(restUpdate);
+  if (acl._rperm || acl._wperm || acl._acl) {
+    mongoUpdate.$set = {};
+    if (acl._rperm) {
+      mongoUpdate.$set._rperm = acl._rperm;
+    }
+    if (acl._wperm) {
+      mongoUpdate.$set._wperm = acl._wperm;
+    }
+    if (acl._acl) {
+      mongoUpdate.$set._acl = acl._acl;
+    }
+  }
+  for (var restKey in restUpdate) {
+    if (restUpdate[restKey] && restUpdate[restKey].__type === 'Relation') {
+      continue;
+    }
+    var out = transformKeyValueForUpdate(className, restKey, restUpdate[restKey], parseFormatSchema);
+
+    // If the output value is an object with any $ keys, it's an
+    // operator that needs to be lifted onto the top level update
+    // object.
+    if (typeof out.value === 'object' && out.value !== null && out.value.__op) {
+      mongoUpdate[out.value.__op] = mongoUpdate[out.value.__op] || {};
+      mongoUpdate[out.value.__op][out.key] = out.value.arg;
+    } else {
+      mongoUpdate['$set'] = mongoUpdate['$set'] || {};
+      mongoUpdate['$set'][out.key] = out.value;
+    }
+  }
+  return mongoUpdate;
+};
+
+// Add the legacy _acl format.
+const addLegacyACL = restObject => {
+  const restObjectCopy = {
+    ...restObject
+  };
+  const _acl = {};
+  if (restObject._wperm) {
+    restObject._wperm.forEach(entry => {
+      _acl[entry] = {
+        w: true
+      };
+    });
+    restObjectCopy._acl = _acl;
+  }
+  if (restObject._rperm) {
+    restObject._rperm.forEach(entry => {
+      if (!(entry in _acl)) {
+        _acl[entry] = {
+          r: true
+        };
+      } else {
+        _acl[entry].r = true;
+      }
+    });
+    restObjectCopy._acl = _acl;
+  }
+  return restObjectCopy;
+};
+
+// A sentinel value that helper transformations return when they
+// cannot perform a transformation
+function CannotTransform() {}
+const transformInteriorAtom = atom => {
+  // TODO: check validity harder for the __type-defined types
+  if (typeof atom === 'object' && atom && !Utils.isDate(atom) && atom.__type === 'Pointer') {
+    return {
+      __type: 'Pointer',
+      className: atom.className,
+      objectId: atom.objectId
+    };
+  } else if (typeof atom === 'function' || typeof atom === 'symbol') {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`);
+  } else if (DateCoder.isValidJSON(atom)) {
+    return DateCoder.JSONToDatabase(atom);
+  } else if (BytesCoder.isValidJSON(atom)) {
+    return BytesCoder.JSONToDatabase(atom);
+  } else if (typeof atom === 'object' && atom && atom.$regex !== undefined) {
+    return new RegExp(atom.$regex);
+  } else {
+    return atom;
+  }
+};
+
+// Helper function to transform an atom from REST format to Mongo format.
+// An atom is anything that can't contain other expressions. So it
+// includes things where objects are used to represent other
+// datatypes, like pointers and dates, but it does not include objects
+// or arrays with generic stuff inside.
+// Raises an error if this cannot possibly be valid REST format.
+// Returns CannotTransform if it's just not an atom
+function transformTopLevelAtom(atom, field) {
+  switch (typeof atom) {
+    case 'number':
+    case 'boolean':
+    case 'undefined':
+      return atom;
+    case 'string':
+      if (field && field.type === 'Pointer') {
+        return `${field.targetClass}$${atom}`;
+      }
+      return atom;
+    case 'symbol':
+    case 'function':
+      throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`);
+    case 'object':
+      if (Utils.isDate(atom)) {
+        // Technically dates are not rest format, but, it seems pretty
+        // clear what they should be transformed to, so let's just do it.
+        return atom;
+      }
+      if (atom === null) {
+        return atom;
+      }
+
+      // TODO: check validity harder for the __type-defined types
+      if (atom.__type == 'Pointer') {
+        return `${atom.className}$${atom.objectId}`;
+      }
+      if (DateCoder.isValidJSON(atom)) {
+        return DateCoder.JSONToDatabase(atom);
+      }
+      if (BytesCoder.isValidJSON(atom)) {
+        return BytesCoder.JSONToDatabase(atom);
+      }
+      if (GeoPointCoder.isValidJSON(atom)) {
+        return GeoPointCoder.JSONToDatabase(atom);
+      }
+      if (PolygonCoder.isValidJSON(atom)) {
+        return PolygonCoder.JSONToDatabase(atom);
+      }
+      if (FileCoder.isValidJSON(atom)) {
+        return FileCoder.JSONToDatabase(atom);
+      }
+      return CannotTransform;
+    default:
+      // I don't think typeof can ever let us get here
+      throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, `really did not expect value: ${atom}`);
+  }
+}
+
+// Transforms a query constraint from REST API format to Mongo format.
+// A constraint is something with fields like $lt.
+// If it is not a valid constraint but it could be a valid something
+// else, return CannotTransform.
+// inArray is whether this is an array field.
+function transformConstraint(constraint, field, queryKey, count = false) {
+  const inArray = field && field.type && field.type === 'Array';
+  // Check wether the given key has `.`
+  const isNestedKey = queryKey.indexOf('.') > -1;
+  if (typeof constraint !== 'object' || !constraint) {
+    return CannotTransform;
+  }
+  // For inArray or nested key, we need to transform the interior atom
+  const transformFunction = inArray || isNestedKey ? transformInteriorAtom : transformTopLevelAtom;
+  const transformer = atom => {
+    const result = transformFunction(atom, field);
+    if (result === CannotTransform) {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, `bad atom: ${JSON.stringify(atom)}`);
+    }
+    return result;
+  };
+  // keys is the constraints in reverse alphabetical order.
+  // This is a hack so that:
+  //   $regex is handled before $options
+  //   $nearSphere is handled before $maxDistance
+  var keys = Object.keys(constraint).sort().reverse();
+  var answer = {};
+  for (var key of keys) {
+    switch (key) {
+      case '$lt':
+      case '$lte':
+      case '$gt':
+      case '$gte':
+      case '$exists':
+      case '$ne':
+      case '$eq':
+        {
+          const val = constraint[key];
+          if (val && typeof val === 'object' && val.$relativeTime) {
+            if (field && field.type !== 'Date') {
+              throw new Parse.Error(Parse.Error.INVALID_JSON, '$relativeTime can only be used with Date field');
+            }
+            switch (key) {
+              case '$exists':
+              case '$ne':
+              case '$eq':
+                throw new Parse.Error(Parse.Error.INVALID_JSON, '$relativeTime can only be used with the $lt, $lte, $gt, and $gte operators');
+            }
+            const parserResult = Utils.relativeTimeToDate(val.$relativeTime);
+            if (parserResult.status === 'success') {
+              answer[key] = parserResult.result;
+              break;
+            }
+            _logger.default.info('Error while parsing relative date', parserResult);
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $relativeTime (${key}) value. ${parserResult.info}`);
+          }
+          answer[key] = transformer(val);
+          break;
+        }
+      case '$in':
+      case '$nin':
+        {
+          const arr = constraint[key];
+          if (!Array.isArray(arr)) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value');
+          }
+          answer[key] = _lodash.default.flatMap(arr, value => {
+            return (atom => {
+              if (Array.isArray(atom)) {
+                return value.map(transformer);
+              } else {
+                return transformer(atom);
+              }
+            })(value);
+          });
+          break;
+        }
+      case '$all':
+        {
+          const arr = constraint[key];
+          if (!Array.isArray(arr)) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value');
+          }
+          answer[key] = arr.map(transformInteriorAtom);
+          const values = answer[key];
+          if (isAnyValueRegex(values) && !isAllValuesRegexOrNone(values)) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, 'All $all values must be of regex type or none: ' + values);
+          }
+          break;
+        }
+      case '$regex':
+        var s = constraint[key];
+        if (typeof s !== 'string') {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad regex: ' + s);
+        }
+        answer[key] = s;
+        break;
+      case '$containedBy':
+        {
+          const arr = constraint[key];
+          if (!Array.isArray(arr)) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $containedBy: should be an array`);
+          }
+          answer.$elemMatch = {
+            $nin: arr.map(transformer)
+          };
+          break;
+        }
+      case '$options':
+        answer[key] = constraint[key];
+        break;
+      case '$text':
+        {
+          const search = constraint[key].$search;
+          if (typeof search !== 'object') {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $search, should be object`);
+          }
+          if (!search.$term || typeof search.$term !== 'string') {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $term, should be string`);
+          } else {
+            answer[key] = {
+              $search: search.$term
+            };
+          }
+          if (search.$language && typeof search.$language !== 'string') {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $language, should be string`);
+          } else if (search.$language) {
+            answer[key].$language = search.$language;
+          }
+          if (search.$caseSensitive && typeof search.$caseSensitive !== 'boolean') {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $caseSensitive, should be boolean`);
+          } else if (search.$caseSensitive) {
+            answer[key].$caseSensitive = search.$caseSensitive;
+          }
+          if (search.$diacriticSensitive && typeof search.$diacriticSensitive !== 'boolean') {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $diacriticSensitive, should be boolean`);
+          } else if (search.$diacriticSensitive) {
+            answer[key].$diacriticSensitive = search.$diacriticSensitive;
+          }
+          break;
+        }
+      case '$nearSphere':
+        {
+          const point = constraint[key];
+          if (count) {
+            answer.$geoWithin = {
+              $centerSphere: [[point.longitude, point.latitude], constraint.$maxDistance]
+            };
+          } else {
+            answer[key] = [point.longitude, point.latitude];
+          }
+          break;
+        }
+      case '$maxDistance':
+        {
+          if (count) {
+            break;
+          }
+          answer[key] = constraint[key];
+          break;
+        }
+      // The SDKs don't seem to use these but they are documented in the
+      // REST API docs.
+      case '$maxDistanceInRadians':
+        answer['$maxDistance'] = constraint[key];
+        break;
+      case '$maxDistanceInMiles':
+        answer['$maxDistance'] = constraint[key] / 3959;
+        break;
+      case '$maxDistanceInKilometers':
+        answer['$maxDistance'] = constraint[key] / 6371;
+        break;
+      case '$select':
+      case '$dontSelect':
+        throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, 'the ' + key + ' constraint is not supported yet');
+      case '$within':
+        var box = constraint[key]['$box'];
+        if (!box || box.length != 2) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'malformatted $within arg');
+        }
+        answer[key] = {
+          $box: [[box[0].longitude, box[0].latitude], [box[1].longitude, box[1].latitude]]
+        };
+        break;
+      case '$geoWithin':
+        {
+          const polygon = constraint[key]['$polygon'];
+          const centerSphere = constraint[key]['$centerSphere'];
+          if (polygon !== undefined) {
+            let points;
+            if (typeof polygon === 'object' && polygon.__type === 'Polygon') {
+              if (!polygon.coordinates || polygon.coordinates.length < 3) {
+                throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs');
+              }
+              points = polygon.coordinates;
+            } else if (Array.isArray(polygon)) {
+              if (polygon.length < 3) {
+                throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints');
+              }
+              points = polygon;
+            } else {
+              throw new Parse.Error(Parse.Error.INVALID_JSON, "bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint's");
+            }
+            points = points.map(point => {
+              if (Array.isArray(point) && point.length === 2) {
+                Parse.GeoPoint._validate(point[1], point[0]);
+                return point;
+              }
+              if (!GeoPointCoder.isValidJSON(point)) {
+                throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value');
+              } else {
+                Parse.GeoPoint._validate(point.latitude, point.longitude);
+              }
+              return [point.longitude, point.latitude];
+            });
+            answer[key] = {
+              $polygon: points
+            };
+          } else if (centerSphere !== undefined) {
+            if (!Array.isArray(centerSphere) || centerSphere.length < 2) {
+              throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance');
+            }
+            // Get point, convert to geo point if necessary and validate
+            let point = centerSphere[0];
+            if (Array.isArray(point) && point.length === 2) {
+              point = new Parse.GeoPoint(point[1], point[0]);
+            } else if (!GeoPointCoder.isValidJSON(point)) {
+              throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid');
+            }
+            Parse.GeoPoint._validate(point.latitude, point.longitude);
+            // Get distance and validate
+            const distance = centerSphere[1];
+            if (isNaN(distance) || distance < 0) {
+              throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid');
+            }
+            answer[key] = {
+              $centerSphere: [[point.longitude, point.latitude], distance]
+            };
+          }
+          break;
+        }
+      case '$geoIntersects':
+        {
+          const point = constraint[key]['$point'];
+          if (!GeoPointCoder.isValidJSON(point)) {
+            throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoIntersect value; $point should be GeoPoint');
+          } else {
+            Parse.GeoPoint._validate(point.latitude, point.longitude);
+          }
+          answer[key] = {
+            $geometry: {
+              type: 'Point',
+              coordinates: [point.longitude, point.latitude]
+            }
+          };
+          break;
+        }
+      default:
+        if (key.match(/^\$+/)) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad constraint: ' + key);
+        }
+        return CannotTransform;
+    }
+  }
+  return answer;
+}
+
+// Transforms an update operator from REST format to mongo format.
+// To be transformed, the input should have an __op field.
+// If flatten is true, this will flatten operators to their static
+// data format. For example, an increment of 2 would simply become a
+// 2.
+// The output for a non-flattened operator is a hash with __op being
+// the mongo op, and arg being the argument.
+// The output for a flattened operator is just a value.
+// Returns undefined if this should be a no-op.
+
+function transformUpdateOperator({
+  __op,
+  amount,
+  objects
+}, flatten) {
+  switch (__op) {
+    case 'Delete':
+      if (flatten) {
+        return undefined;
+      } else {
+        return {
+          __op: '$unset',
+          arg: ''
+        };
+      }
+    case 'Increment':
+      if (typeof amount !== 'number') {
+        throw new Parse.Error(Parse.Error.INVALID_JSON, 'incrementing must provide a number');
+      }
+      if (flatten) {
+        return amount;
+      } else {
+        return {
+          __op: '$inc',
+          arg: amount
+        };
+      }
+    case 'SetOnInsert':
+      if (flatten) {
+        return amount;
+      } else {
+        return {
+          __op: '$setOnInsert',
+          arg: amount
+        };
+      }
+    case 'Add':
+    case 'AddUnique':
+      if (!Array.isArray(objects)) {
+        throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
+      }
+      var toAdd = objects.map(transformInteriorAtom);
+      if (flatten) {
+        return toAdd;
+      } else {
+        var mongoOp = {
+          Add: '$push',
+          AddUnique: '$addToSet'
+        }[__op];
+        return {
+          __op: mongoOp,
+          arg: {
+            $each: toAdd
+          }
+        };
+      }
+    case 'Remove':
+      if (!Array.isArray(objects)) {
+        throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to remove must be an array');
+      }
+      var toRemove = objects.map(transformInteriorAtom);
+      if (flatten) {
+        return [];
+      } else {
+        return {
+          __op: '$pullAll',
+          arg: toRemove
+        };
+      }
+    default:
+      throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, `The ${__op} operator is not supported yet.`);
+  }
+}
+function mapValues(object, iterator) {
+  const result = {};
+  Object.keys(object).forEach(key => {
+    result[key] = iterator(object[key]);
+  });
+  return result;
+}
+const nestedMongoObjectToNestedParseObject = mongoObject => {
+  switch (typeof mongoObject) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+    case 'undefined':
+      return mongoObject;
+    case 'symbol':
+    case 'function':
+      throw 'bad value in nestedMongoObjectToNestedParseObject';
+    case 'object':
+      if (mongoObject === null) {
+        return null;
+      }
+      if (Array.isArray(mongoObject)) {
+        return mongoObject.map(nestedMongoObjectToNestedParseObject);
+      }
+      if (Utils.isDate(mongoObject)) {
+        return Parse._encode(mongoObject);
+      }
+      if (mongoObject instanceof mongodb.Long) {
+        return mongoObject.toNumber();
+      }
+      if (mongoObject instanceof mongodb.Double) {
+        return mongoObject.value;
+      }
+      if (BytesCoder.isValidDatabaseObject(mongoObject)) {
+        return BytesCoder.databaseToJSON(mongoObject);
+      }
+      if (Object.prototype.hasOwnProperty.call(mongoObject, '__type') && mongoObject.__type == 'Date' && Utils.isDate(mongoObject.iso)) {
+        mongoObject.iso = mongoObject.iso.toJSON();
+        return mongoObject;
+      }
+      return mapValues(mongoObject, nestedMongoObjectToNestedParseObject);
+    default:
+      throw 'unknown js type';
+  }
+};
+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) => {
+  switch (typeof mongoObject) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+    case 'undefined':
+      return mongoObject;
+    case 'symbol':
+    case 'function':
+      throw 'bad value in mongoObjectToParseObject';
+    case 'object':
+      {
+        if (mongoObject === null) {
+          return null;
+        }
+        if (Array.isArray(mongoObject)) {
+          return mongoObject.map(nestedMongoObjectToNestedParseObject);
+        }
+        if (Utils.isDate(mongoObject)) {
+          return Parse._encode(mongoObject);
+        }
+        if (mongoObject instanceof mongodb.Long) {
+          return mongoObject.toNumber();
+        }
+        if (mongoObject instanceof mongodb.Double) {
+          return mongoObject.value;
+        }
+        if (BytesCoder.isValidDatabaseObject(mongoObject)) {
+          return BytesCoder.databaseToJSON(mongoObject);
+        }
+        const restObject = {};
+        if (mongoObject._rperm || mongoObject._wperm) {
+          restObject._rperm = mongoObject._rperm || [];
+          restObject._wperm = mongoObject._wperm || [];
+          delete mongoObject._rperm;
+          delete mongoObject._wperm;
+        }
+        for (var key in mongoObject) {
+          switch (key) {
+            case '_id':
+              restObject['objectId'] = '' + mongoObject[key];
+              break;
+            case '_hashed_password':
+              restObject._hashed_password = mongoObject[key];
+              break;
+            case '_acl':
+              break;
+            case '_email_verify_token':
+            case '_perishable_token':
+            case '_perishable_token_expires_at':
+            case '_password_changed_at':
+            case '_tombstone':
+            case '_email_verify_token_expires_at':
+            case '_account_lockout_expires_at':
+            case '_failed_login_count':
+            case '_password_history':
+              // Those keys will be deleted if needed in the DB Controller
+              restObject[key] = mongoObject[key];
+              break;
+            case '_session_token':
+              restObject['sessionToken'] = mongoObject[key];
+              break;
+            case 'updatedAt':
+            case '_updated_at':
+              restObject['updatedAt'] = Parse._encode(new Date(mongoObject[key])).iso;
+              break;
+            case 'createdAt':
+            case '_created_at':
+              restObject['createdAt'] = Parse._encode(new Date(mongoObject[key])).iso;
+              break;
+            case 'expiresAt':
+            case '_expiresAt':
+              restObject['expiresAt'] = Parse._encode(new Date(mongoObject[key]));
+              break;
+            case 'lastUsed':
+            case '_last_used':
+              restObject['lastUsed'] = Parse._encode(new Date(mongoObject[key])).iso;
+              break;
+            case 'timesUsed':
+            case 'times_used':
+              restObject['timesUsed'] = mongoObject[key];
+              break;
+            case 'authData':
+              if (className === '_User') {
+                _logger.default.warn('ignoring authData in _User as this key is reserved to be synthesized of `_auth_data_*` keys');
+              } else {
+                restObject['authData'] = mongoObject[key];
+              }
+              break;
+            default:
+              // Check other auth data keys
+              var authDataMatch = key.match(/^_auth_data_([a-zA-Z0-9_]+)$/);
+              if (authDataMatch && className === '_User') {
+                var provider = authDataMatch[1];
+                restObject['authData'] = restObject['authData'] || {};
+                restObject['authData'][provider] = mongoObject[key];
+                break;
+              }
+              if (key.indexOf('_p_') == 0) {
+                var newKey = key.substring(3);
+                if (!schema.fields[newKey]) {
+                  _logger.default.info('transform.js', 'Found a pointer column not in the schema, dropping it.', className, newKey);
+                  break;
+                }
+                if (schema.fields[newKey].type !== 'Pointer') {
+                  _logger.default.info('transform.js', 'Found a pointer in a non-pointer column, dropping it.', className, key);
+                  break;
+                }
+                if (mongoObject[key] === null) {
+                  break;
+                }
+                restObject[newKey] = transformPointerString(schema, newKey, mongoObject[key]);
+                break;
+              } else if (key[0] == '_' && key != '__type') {
+                throw 'bad key in untransform: ' + key;
+              } else {
+                var value = mongoObject[key];
+                if (schema.fields[key] && schema.fields[key].type === 'File' && FileCoder.isValidDatabaseObject(value)) {
+                  restObject[key] = FileCoder.databaseToJSON(value);
+                  break;
+                }
+                if (schema.fields[key] && schema.fields[key].type === 'GeoPoint' && GeoPointCoder.isValidDatabaseObject(value)) {
+                  restObject[key] = GeoPointCoder.databaseToJSON(value);
+                  break;
+                }
+                if (schema.fields[key] && schema.fields[key].type === 'Polygon' && PolygonCoder.isValidDatabaseObject(value)) {
+                  restObject[key] = PolygonCoder.databaseToJSON(value);
+                  break;
+                }
+                if (schema.fields[key] && schema.fields[key].type === 'Bytes' && BytesCoder.isValidDatabaseObject(value)) {
+                  restObject[key] = BytesCoder.databaseToJSON(value);
+                  break;
+                }
+              }
+              restObject[key] = nestedMongoObjectToNestedParseObject(mongoObject[key]);
+          }
+        }
+        const relationFieldNames = Object.keys(schema.fields).filter(fieldName => schema.fields[fieldName].type === 'Relation');
+        const relationFields = {};
+        relationFieldNames.forEach(relationFieldName => {
+          relationFields[relationFieldName] = {
+            __type: 'Relation',
+            className: schema.fields[relationFieldName].targetClass
+          };
+        });
+        return {
+          ...restObject,
+          ...relationFields
+        };
+      }
+    default:
+      throw 'unknown js type';
+  }
+};
+var DateCoder = {
+  JSONToDatabase(json) {
+    return new Date(json.iso);
+  },
+  isValidJSON(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'Date';
+  }
+};
+var BytesCoder = {
+  base64Pattern: new RegExp('^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$'),
+  isBase64Value(object) {
+    if (typeof object !== 'string') {
+      return false;
+    }
+    return this.base64Pattern.test(object);
+  },
+  databaseToJSON(object) {
+    let value;
+    if (this.isBase64Value(object)) {
+      value = object;
+    } else {
+      value = object.buffer.toString('base64');
+    }
+    return {
+      __type: 'Bytes',
+      base64: value
+    };
+  },
+  isValidDatabaseObject(object) {
+    return object instanceof mongodb.Binary || this.isBase64Value(object);
+  },
+  JSONToDatabase(json) {
+    return new mongodb.Binary(Buffer.from(json.base64, 'base64'));
+  },
+  isValidJSON(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'Bytes';
+  }
+};
+var GeoPointCoder = {
+  databaseToJSON(object) {
+    return {
+      __type: 'GeoPoint',
+      latitude: object[1],
+      longitude: object[0]
+    };
+  },
+  isValidDatabaseObject(object) {
+    return Array.isArray(object) && object.length == 2;
+  },
+  JSONToDatabase(json) {
+    return [json.longitude, json.latitude];
+  },
+  isValidJSON(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'GeoPoint';
+  }
+};
+var PolygonCoder = {
+  databaseToJSON(object) {
+    // Convert lng/lat -> lat/lng
+    const coords = object.coordinates[0].map(coord => {
+      return [coord[1], coord[0]];
+    });
+    return {
+      __type: 'Polygon',
+      coordinates: coords
+    };
+  },
+  isValidDatabaseObject(object) {
+    const coords = object.coordinates[0];
+    if (object.type !== 'Polygon' || !Array.isArray(coords)) {
+      return false;
+    }
+    for (let i = 0; i < coords.length; i++) {
+      const point = coords[i];
+      if (!GeoPointCoder.isValidDatabaseObject(point)) {
+        return false;
+      }
+      Parse.GeoPoint._validate(parseFloat(point[1]), parseFloat(point[0]));
+    }
+    return true;
+  },
+  JSONToDatabase(json) {
+    let coords = json.coordinates;
+    // Add first point to the end to close polygon
+    if (coords[0][0] !== coords[coords.length - 1][0] || coords[0][1] !== coords[coords.length - 1][1]) {
+      coords.push(coords[0]);
+    }
+    const unique = coords.filter((item, index, ar) => {
+      let foundIndex = -1;
+      for (let i = 0; i < ar.length; i += 1) {
+        const pt = ar[i];
+        if (pt[0] === item[0] && pt[1] === item[1]) {
+          foundIndex = i;
+          break;
+        }
+      }
+      return foundIndex === index;
+    });
+    if (unique.length < 3) {
+      throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'GeoJSON: Loop must have at least 3 different vertices');
+    }
+    // Convert lat/long -> long/lat
+    coords = coords.map(coord => {
+      return [coord[1], coord[0]];
+    });
+    return {
+      type: 'Polygon',
+      coordinates: [coords]
+    };
+  },
+  isValidJSON(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'Polygon';
+  }
+};
+var FileCoder = {
+  databaseToJSON(object) {
+    return {
+      __type: 'File',
+      name: object
+    };
+  },
+  isValidDatabaseObject(object) {
+    return typeof object === 'string';
+  },
+  JSONToDatabase(json) {
+    return json.name;
+  },
+  isValidJSON(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'File';
+  }
+};
+module.exports = {
+  transformKey,
+  parseObjectToMongoObjectForCreate,
+  transformUpdate,
+  transformWhere,
+  mongoObjectToParseObject,
+  transformConstraint,
+  transformPointerString
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_logger","_interopRequireDefault","require","_lodash","e","__esModule","default","mongodb","Parse","Utils","transformKey","className","fieldName","schema","fields","__type","type","transformKeyValueForUpdate","restKey","restValue","parseFormatSchema","key","timeField","includes","value","parseInt","transformTopLevelAtom","CannotTransform","Date","indexOf","Array","isArray","map","transformInteriorValue","transformUpdateOperator","mapValues","isRegex","isRegExp","isStartsWithRegex","matches","toString","match","isAllValuesRegexOrNone","values","length","firstValuesIsRegex","i","isAnyValueRegex","some","Object","keys","Error","INVALID_NESTED_KEY","transformInteriorAtom","isDate","valueAsDate","transformQueryKeyValue","count","subQuery","transformWhere","authDataMatch","provider","subField","expectedTypeIsArray","expectedTypeIsPointer","field","transformedConstraint","transformConstraint","$text","$elemMatch","$all","transformRes","INVALID_JSON","restWhere","mongoWhere","out","parseObjectKeyValueToMongoObjectKeyValue","transformedValue","coercedToDate","INVALID_KEY_NAME","parseObjectToMongoObjectForCreate","restCreate","addLegacyACL","mongoCreate","undefined","createdAt","_created_at","iso","updatedAt","_updated_at","transformUpdate","restUpdate","mongoUpdate","acl","_rperm","_wperm","_acl","$set","__op","arg","restObject","restObjectCopy","forEach","entry","w","r","atom","objectId","DateCoder","isValidJSON","JSONToDatabase","BytesCoder","$regex","RegExp","targetClass","GeoPointCoder","PolygonCoder","FileCoder","INTERNAL_SERVER_ERROR","constraint","queryKey","inArray","isNestedKey","transformFunction","transformer","result","JSON","stringify","sort","reverse","answer","val","$relativeTime","parserResult","relativeTimeToDate","status","log","info","arr","_","flatMap","s","$nin","search","$search","$term","$language","$caseSensitive","$diacriticSensitive","point","$geoWithin","$centerSphere","longitude","latitude","$maxDistance","COMMAND_UNAVAILABLE","box","$box","polygon","centerSphere","points","coordinates","GeoPoint","_validate","$polygon","distance","isNaN","$geometry","amount","objects","flatten","toAdd","mongoOp","Add","AddUnique","$each","toRemove","object","iterator","nestedMongoObjectToNestedParseObject","mongoObject","_encode","Long","toNumber","Double","isValidDatabaseObject","databaseToJSON","prototype","hasOwnProperty","call","toJSON","transformPointerString","pointerString","objData","split","mongoObjectToParseObject","_hashed_password","warn","newKey","substring","relationFieldNames","filter","relationFields","relationFieldName","json","base64Pattern","isBase64Value","test","buffer","base64","Binary","Buffer","from","coords","coord","parseFloat","push","unique","item","index","ar","foundIndex","pt","name","module","exports"],"sources":["../../../../src/Adapters/Storage/Mongo/MongoTransform.js"],"sourcesContent":["import log from '../../../logger';\nimport _ from 'lodash';\nvar mongodb = require('mongodb');\nvar Parse = require('parse/node').Parse;\nconst Utils = require('../../../Utils');\n\nconst transformKey = (className, fieldName, schema) => {\n  // Check if the schema is known since it's a built-in field.\n  switch (fieldName) {\n    case 'objectId':\n      return '_id';\n    case 'createdAt':\n      return '_created_at';\n    case 'updatedAt':\n      return '_updated_at';\n    case 'sessionToken':\n      return '_session_token';\n    case 'lastUsed':\n      return '_last_used';\n    case 'timesUsed':\n      return 'times_used';\n  }\n\n  if (schema.fields[fieldName] && schema.fields[fieldName].__type == 'Pointer') {\n    fieldName = '_p_' + fieldName;\n  } else if (schema.fields[fieldName] && schema.fields[fieldName].type == 'Pointer') {\n    fieldName = '_p_' + fieldName;\n  }\n\n  return fieldName;\n};\n\nconst transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSchema) => {\n  // Check if the schema is known since it's a built-in field.\n  var key = restKey;\n  var timeField = false;\n  switch (key) {\n    case 'objectId':\n    case '_id':\n      if (['_GlobalConfig', '_GraphQLConfig'].includes(className)) {\n        return {\n          key: key,\n          value: parseInt(restValue),\n        };\n      }\n      key = '_id';\n      break;\n    case 'createdAt':\n    case '_created_at':\n      key = '_created_at';\n      timeField = true;\n      break;\n    case 'updatedAt':\n    case '_updated_at':\n      key = '_updated_at';\n      timeField = true;\n      break;\n    case 'sessionToken':\n    case '_session_token':\n      key = '_session_token';\n      break;\n    case 'expiresAt':\n    case '_expiresAt':\n      key = 'expiresAt';\n      timeField = true;\n      break;\n    case '_email_verify_token_expires_at':\n      key = '_email_verify_token_expires_at';\n      timeField = true;\n      break;\n    case '_account_lockout_expires_at':\n      key = '_account_lockout_expires_at';\n      timeField = true;\n      break;\n    case '_failed_login_count':\n      key = '_failed_login_count';\n      break;\n    case '_perishable_token_expires_at':\n      key = '_perishable_token_expires_at';\n      timeField = true;\n      break;\n    case '_password_changed_at':\n      key = '_password_changed_at';\n      timeField = true;\n      break;\n    case '_rperm':\n    case '_wperm':\n      return { key: key, value: restValue };\n    case 'lastUsed':\n    case '_last_used':\n      key = '_last_used';\n      timeField = true;\n      break;\n    case 'timesUsed':\n    case 'times_used':\n      key = 'times_used';\n      timeField = true;\n      break;\n  }\n\n  if (\n    (parseFormatSchema.fields[key] && parseFormatSchema.fields[key].type === 'Pointer') ||\n    (!key.includes('.') &&\n      !parseFormatSchema.fields[key] &&\n      restValue &&\n      restValue.__type == 'Pointer') // Do not use the _p_ prefix for pointers inside nested documents\n  ) {\n    key = '_p_' + key;\n  }\n\n  // Handle atomic values\n  var value = transformTopLevelAtom(restValue);\n  if (value !== CannotTransform) {\n    if (timeField && typeof value === 'string') {\n      value = new Date(value);\n    }\n    if (restKey.indexOf('.') > 0) {\n      return { key, value: restValue };\n    }\n    return { key, value };\n  }\n\n  // Handle arrays\n  if (Array.isArray(restValue)) {\n    value = restValue.map(transformInteriorValue);\n    return { key, value };\n  }\n\n  // Handle update operators\n  if (typeof restValue === 'object' && '__op' in restValue) {\n    return { key, value: transformUpdateOperator(restValue, false) };\n  }\n\n  // Handle normal objects by recursing\n  value = mapValues(restValue, transformInteriorValue);\n  return { key, value };\n};\n\nconst isRegex = value => {\n  return value && Utils.isRegExp(value);\n};\n\nconst isStartsWithRegex = value => {\n  if (!isRegex(value)) {\n    return false;\n  }\n\n  const matches = value.toString().match(/\\/\\^\\\\Q.*\\\\E\\//);\n  return !!matches;\n};\n\nconst isAllValuesRegexOrNone = values => {\n  if (!values || !Array.isArray(values) || values.length === 0) {\n    return true;\n  }\n\n  const firstValuesIsRegex = isStartsWithRegex(values[0]);\n  if (values.length === 1) {\n    return firstValuesIsRegex;\n  }\n\n  for (let i = 1, length = values.length; i < length; ++i) {\n    if (firstValuesIsRegex !== isStartsWithRegex(values[i])) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\nconst isAnyValueRegex = values => {\n  return values.some(function (value) {\n    return isRegex(value);\n  });\n};\n\nconst transformInteriorValue = restValue => {\n  if (\n    restValue !== null &&\n    typeof restValue === 'object' &&\n    Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))\n  ) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_NESTED_KEY,\n      \"Nested keys should not contain the '$' or '.' characters\"\n    );\n  }\n  // Handle atomic values\n  var value = transformInteriorAtom(restValue);\n  if (value !== CannotTransform) {\n    if (value && typeof value === 'object') {\n      if (Utils.isDate(value)) {\n        return value;\n      }\n      if (Array.isArray(value)) {\n        value = value.map(transformInteriorValue);\n      } else {\n        value = mapValues(value, transformInteriorValue);\n      }\n    }\n    return value;\n  }\n\n  // Handle arrays\n  if (Array.isArray(restValue)) {\n    return restValue.map(transformInteriorValue);\n  }\n\n  // Handle update operators\n  if (typeof restValue === 'object' && '__op' in restValue) {\n    return transformUpdateOperator(restValue, true);\n  }\n\n  // Handle normal objects by recursing\n  return mapValues(restValue, transformInteriorValue);\n};\n\nconst valueAsDate = value => {\n  if (typeof value === 'string') {\n    return new Date(value);\n  } else if (Utils.isDate(value)) {\n    return value;\n  }\n  return false;\n};\n\nfunction transformQueryKeyValue(className, key, value, schema, count = false) {\n  switch (key) {\n    case 'createdAt':\n      if (valueAsDate(value)) {\n        return { key: '_created_at', value: valueAsDate(value) };\n      }\n      key = '_created_at';\n      break;\n    case 'updatedAt':\n      if (valueAsDate(value)) {\n        return { key: '_updated_at', value: valueAsDate(value) };\n      }\n      key = '_updated_at';\n      break;\n    case 'expiresAt':\n      if (valueAsDate(value)) {\n        return { key: 'expiresAt', value: valueAsDate(value) };\n      }\n      break;\n    case '_email_verify_token_expires_at':\n      if (valueAsDate(value)) {\n        return {\n          key: '_email_verify_token_expires_at',\n          value: valueAsDate(value),\n        };\n      }\n      break;\n    case 'objectId': {\n      if (['_GlobalConfig', '_GraphQLConfig'].includes(className)) {\n        value = parseInt(value);\n      }\n      return { key: '_id', value };\n    }\n    case '_account_lockout_expires_at':\n      if (valueAsDate(value)) {\n        return {\n          key: '_account_lockout_expires_at',\n          value: valueAsDate(value),\n        };\n      }\n      break;\n    case '_failed_login_count':\n      return { key, value };\n    case 'sessionToken':\n      return { key: '_session_token', value };\n    case '_perishable_token_expires_at':\n      if (valueAsDate(value)) {\n        return {\n          key: '_perishable_token_expires_at',\n          value: valueAsDate(value),\n        };\n      }\n      break;\n    case '_password_changed_at':\n      if (valueAsDate(value)) {\n        return { key: '_password_changed_at', value: valueAsDate(value) };\n      }\n      break;\n    case '_rperm':\n    case '_wperm':\n    case '_perishable_token':\n    case '_email_verify_token':\n      return { key, value };\n    case '$or':\n    case '$and':\n    case '$nor':\n      return {\n        key: key,\n        value: value.map(subQuery => transformWhere(className, subQuery, schema, count)),\n      };\n    case 'lastUsed':\n      if (valueAsDate(value)) {\n        return { key: '_last_used', value: valueAsDate(value) };\n      }\n      key = '_last_used';\n      break;\n    case 'timesUsed':\n      return { key: 'times_used', value: value };\n    default: {\n      // Other auth data\n      const authDataMatch = key.match(/^authData\\.([a-zA-Z0-9_]+)(\\.(.+))?$/);\n      if (authDataMatch && className === '_User') {\n        const provider = authDataMatch[1];\n        const subField = authDataMatch[3];\n        return { key: `_auth_data_${provider}${subField ? `.${subField}` : ''}`, value };\n      }\n    }\n  }\n\n  const expectedTypeIsArray = schema && schema.fields[key] && schema.fields[key].type === 'Array';\n\n  const expectedTypeIsPointer =\n    schema && schema.fields[key] && schema.fields[key].type === 'Pointer';\n\n  const field = schema && schema.fields[key];\n  if (\n    expectedTypeIsPointer ||\n    (!schema && !key.includes('.') && value && value.__type === 'Pointer')\n  ) {\n    key = '_p_' + key;\n  }\n\n  // Handle query constraints\n  const transformedConstraint = transformConstraint(value, field, key, count);\n  if (transformedConstraint !== CannotTransform) {\n    if (transformedConstraint.$text) {\n      return { key: '$text', value: transformedConstraint.$text };\n    }\n    if (transformedConstraint.$elemMatch) {\n      return { key: '$nor', value: [{ [key]: transformedConstraint }] };\n    }\n    return { key, value: transformedConstraint };\n  }\n\n  if (expectedTypeIsArray && !Array.isArray(value)) {\n    return { key, value: { $all: [transformInteriorAtom(value)] } };\n  }\n\n  // Handle atomic values\n  const transformRes = key.includes('.')\n    ? transformInteriorAtom(value)\n    : transformTopLevelAtom(value);\n  if (transformRes !== CannotTransform) {\n    return { key, value: transformRes };\n  } else {\n    throw new Parse.Error(\n      Parse.Error.INVALID_JSON,\n      `You cannot use ${value} as a query parameter.`\n    );\n  }\n}\n\n// Main exposed method to help run queries.\n// restWhere is the \"where\" clause in REST API form.\n// Returns the mongo form of the query.\nfunction transformWhere(className, restWhere, schema, count = false) {\n  const mongoWhere = {};\n  for (const restKey in restWhere) {\n    const out = transformQueryKeyValue(className, restKey, restWhere[restKey], schema, count);\n    mongoWhere[out.key] = out.value;\n  }\n  return mongoWhere;\n}\n\nconst parseObjectKeyValueToMongoObjectKeyValue = (restKey, restValue, schema) => {\n  // Check if the schema is known since it's a built-in field.\n  let transformedValue;\n  let coercedToDate;\n  switch (restKey) {\n    case 'objectId':\n      return { key: '_id', value: restValue };\n    case 'expiresAt':\n      transformedValue = transformTopLevelAtom(restValue);\n      coercedToDate =\n        typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;\n      return { key: 'expiresAt', value: coercedToDate };\n    case '_email_verify_token_expires_at':\n      transformedValue = transformTopLevelAtom(restValue);\n      coercedToDate =\n        typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;\n      return { key: '_email_verify_token_expires_at', value: coercedToDate };\n    case '_account_lockout_expires_at':\n      transformedValue = transformTopLevelAtom(restValue);\n      coercedToDate =\n        typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;\n      return { key: '_account_lockout_expires_at', value: coercedToDate };\n    case '_perishable_token_expires_at':\n      transformedValue = transformTopLevelAtom(restValue);\n      coercedToDate =\n        typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;\n      return { key: '_perishable_token_expires_at', value: coercedToDate };\n    case '_password_changed_at':\n      transformedValue = transformTopLevelAtom(restValue);\n      coercedToDate =\n        typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue;\n      return { key: '_password_changed_at', value: coercedToDate };\n    case '_failed_login_count':\n    case '_rperm':\n    case '_wperm':\n    case '_email_verify_token':\n    case '_hashed_password':\n    case '_perishable_token':\n      return { key: restKey, value: restValue };\n    case 'sessionToken':\n      return { key: '_session_token', value: restValue };\n    default:\n      // Auth data should have been transformed already\n      if (restKey.match(/^authData\\.([a-zA-Z0-9_]+)\\.id$/)) {\n        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'can only query on ' + restKey);\n      }\n      // Trust that the auth data has been transformed and save it directly\n      if (restKey.match(/^_auth_data_[a-zA-Z0-9_]+$/)) {\n        return { key: restKey, value: restValue };\n      }\n  }\n  //skip straight to transformTopLevelAtom for Bytes, they don't show up in the schema for some reason\n  if (restValue && restValue.__type !== 'Bytes') {\n    //Note: We may not know the type of a field here, as the user could be saving (null) to a field\n    //That never existed before, meaning we can't infer the type.\n    if (\n      (schema.fields[restKey] && schema.fields[restKey].type == 'Pointer') ||\n      restValue.__type == 'Pointer'\n    ) {\n      restKey = '_p_' + restKey;\n    }\n  }\n\n  // Handle atomic values\n  var value = transformTopLevelAtom(restValue);\n  if (value !== CannotTransform) {\n    return { key: restKey, value: value };\n  }\n\n  // ACLs are handled before this method is called\n  // If an ACL key still exists here, something is wrong.\n  if (restKey === 'ACL') {\n    throw 'There was a problem transforming an ACL.';\n  }\n\n  // Handle arrays\n  if (Array.isArray(restValue)) {\n    value = restValue.map(transformInteriorValue);\n    return { key: restKey, value: value };\n  }\n\n  // Handle normal objects by recursing\n  if (Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_NESTED_KEY,\n      \"Nested keys should not contain the '$' or '.' characters\"\n    );\n  }\n  value = mapValues(restValue, transformInteriorValue);\n\n  return { key: restKey, value };\n};\n\nconst parseObjectToMongoObjectForCreate = (className, restCreate, schema) => {\n  restCreate = addLegacyACL(restCreate);\n  const mongoCreate = {};\n  for (const restKey in restCreate) {\n    if (restCreate[restKey] && restCreate[restKey].__type === 'Relation') {\n      continue;\n    }\n    const { key, value } = parseObjectKeyValueToMongoObjectKeyValue(\n      restKey,\n      restCreate[restKey],\n      schema\n    );\n    if (value !== undefined) {\n      mongoCreate[key] = value;\n    }\n  }\n\n  // Use the legacy mongo format for createdAt and updatedAt\n  if (mongoCreate.createdAt) {\n    mongoCreate._created_at = new Date(mongoCreate.createdAt.iso || mongoCreate.createdAt);\n    delete mongoCreate.createdAt;\n  }\n  if (mongoCreate.updatedAt) {\n    mongoCreate._updated_at = new Date(mongoCreate.updatedAt.iso || mongoCreate.updatedAt);\n    delete mongoCreate.updatedAt;\n  }\n\n  return mongoCreate;\n};\n\n// Main exposed method to help update old objects.\nconst transformUpdate = (className, restUpdate, parseFormatSchema) => {\n  const mongoUpdate = {};\n  const acl = addLegacyACL(restUpdate);\n  if (acl._rperm || acl._wperm || acl._acl) {\n    mongoUpdate.$set = {};\n    if (acl._rperm) {\n      mongoUpdate.$set._rperm = acl._rperm;\n    }\n    if (acl._wperm) {\n      mongoUpdate.$set._wperm = acl._wperm;\n    }\n    if (acl._acl) {\n      mongoUpdate.$set._acl = acl._acl;\n    }\n  }\n  for (var restKey in restUpdate) {\n    if (restUpdate[restKey] && restUpdate[restKey].__type === 'Relation') {\n      continue;\n    }\n    var out = transformKeyValueForUpdate(\n      className,\n      restKey,\n      restUpdate[restKey],\n      parseFormatSchema\n    );\n\n    // If the output value is an object with any $ keys, it's an\n    // operator that needs to be lifted onto the top level update\n    // object.\n    if (typeof out.value === 'object' && out.value !== null && out.value.__op) {\n      mongoUpdate[out.value.__op] = mongoUpdate[out.value.__op] || {};\n      mongoUpdate[out.value.__op][out.key] = out.value.arg;\n    } else {\n      mongoUpdate['$set'] = mongoUpdate['$set'] || {};\n      mongoUpdate['$set'][out.key] = out.value;\n    }\n  }\n\n  return mongoUpdate;\n};\n\n// Add the legacy _acl format.\nconst addLegacyACL = restObject => {\n  const restObjectCopy = { ...restObject };\n  const _acl = {};\n\n  if (restObject._wperm) {\n    restObject._wperm.forEach(entry => {\n      _acl[entry] = { w: true };\n    });\n    restObjectCopy._acl = _acl;\n  }\n\n  if (restObject._rperm) {\n    restObject._rperm.forEach(entry => {\n      if (!(entry in _acl)) {\n        _acl[entry] = { r: true };\n      } else {\n        _acl[entry].r = true;\n      }\n    });\n    restObjectCopy._acl = _acl;\n  }\n\n  return restObjectCopy;\n};\n\n// A sentinel value that helper transformations return when they\n// cannot perform a transformation\nfunction CannotTransform() {}\n\nconst transformInteriorAtom = atom => {\n  // TODO: check validity harder for the __type-defined types\n  if (typeof atom === 'object' && atom && !Utils.isDate(atom) && atom.__type === 'Pointer') {\n    return {\n      __type: 'Pointer',\n      className: atom.className,\n      objectId: atom.objectId,\n    };\n  } else if (typeof atom === 'function' || typeof atom === 'symbol') {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`);\n  } else if (DateCoder.isValidJSON(atom)) {\n    return DateCoder.JSONToDatabase(atom);\n  } else if (BytesCoder.isValidJSON(atom)) {\n    return BytesCoder.JSONToDatabase(atom);\n  } else if (typeof atom === 'object' && atom && atom.$regex !== undefined) {\n    return new RegExp(atom.$regex);\n  } else {\n    return atom;\n  }\n};\n\n// Helper function to transform an atom from REST format to Mongo format.\n// An atom is anything that can't contain other expressions. So it\n// includes things where objects are used to represent other\n// datatypes, like pointers and dates, but it does not include objects\n// or arrays with generic stuff inside.\n// Raises an error if this cannot possibly be valid REST format.\n// Returns CannotTransform if it's just not an atom\nfunction transformTopLevelAtom(atom, field) {\n  switch (typeof atom) {\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n      return atom;\n    case 'string':\n      if (field && field.type === 'Pointer') {\n        return `${field.targetClass}$${atom}`;\n      }\n      return atom;\n    case 'symbol':\n    case 'function':\n      throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`);\n    case 'object':\n      if (Utils.isDate(atom)) {\n        // Technically dates are not rest format, but, it seems pretty\n        // clear what they should be transformed to, so let's just do it.\n        return atom;\n      }\n\n      if (atom === null) {\n        return atom;\n      }\n\n      // TODO: check validity harder for the __type-defined types\n      if (atom.__type == 'Pointer') {\n        return `${atom.className}$${atom.objectId}`;\n      }\n      if (DateCoder.isValidJSON(atom)) {\n        return DateCoder.JSONToDatabase(atom);\n      }\n      if (BytesCoder.isValidJSON(atom)) {\n        return BytesCoder.JSONToDatabase(atom);\n      }\n      if (GeoPointCoder.isValidJSON(atom)) {\n        return GeoPointCoder.JSONToDatabase(atom);\n      }\n      if (PolygonCoder.isValidJSON(atom)) {\n        return PolygonCoder.JSONToDatabase(atom);\n      }\n      if (FileCoder.isValidJSON(atom)) {\n        return FileCoder.JSONToDatabase(atom);\n      }\n      return CannotTransform;\n\n    default:\n      // I don't think typeof can ever let us get here\n      throw new Parse.Error(\n        Parse.Error.INTERNAL_SERVER_ERROR,\n        `really did not expect value: ${atom}`\n      );\n  }\n}\n\n// Transforms a query constraint from REST API format to Mongo format.\n// A constraint is something with fields like $lt.\n// If it is not a valid constraint but it could be a valid something\n// else, return CannotTransform.\n// inArray is whether this is an array field.\nfunction transformConstraint(constraint, field, queryKey, count = false) {\n  const inArray = field && field.type && field.type === 'Array';\n  // Check wether the given key has `.`\n  const isNestedKey = queryKey.indexOf('.') > -1;\n  if (typeof constraint !== 'object' || !constraint) {\n    return CannotTransform;\n  }\n  // For inArray or nested key, we need to transform the interior atom\n  const transformFunction = (inArray || isNestedKey) ? transformInteriorAtom : transformTopLevelAtom;\n  const transformer = atom => {\n    const result = transformFunction(atom, field);\n    if (result === CannotTransform) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, `bad atom: ${JSON.stringify(atom)}`);\n    }\n    return result;\n  };\n  // keys is the constraints in reverse alphabetical order.\n  // This is a hack so that:\n  //   $regex is handled before $options\n  //   $nearSphere is handled before $maxDistance\n  var keys = Object.keys(constraint).sort().reverse();\n  var answer = {};\n  for (var key of keys) {\n    switch (key) {\n      case '$lt':\n      case '$lte':\n      case '$gt':\n      case '$gte':\n      case '$exists':\n      case '$ne':\n      case '$eq': {\n        const val = constraint[key];\n        if (val && typeof val === 'object' && val.$relativeTime) {\n          if (field && field.type !== 'Date') {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              '$relativeTime can only be used with Date field'\n            );\n          }\n\n          switch (key) {\n            case '$exists':\n            case '$ne':\n            case '$eq':\n              throw new Parse.Error(\n                Parse.Error.INVALID_JSON,\n                '$relativeTime can only be used with the $lt, $lte, $gt, and $gte operators'\n              );\n          }\n\n          const parserResult = Utils.relativeTimeToDate(val.$relativeTime);\n          if (parserResult.status === 'success') {\n            answer[key] = parserResult.result;\n            break;\n          }\n\n          log.info('Error while parsing relative date', parserResult);\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `bad $relativeTime (${key}) value. ${parserResult.info}`\n          );\n        }\n\n        answer[key] = transformer(val);\n        break;\n      }\n\n      case '$in':\n      case '$nin': {\n        const arr = constraint[key];\n        if (!Array.isArray(arr)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value');\n        }\n        answer[key] = _.flatMap(arr, value => {\n          return (atom => {\n            if (Array.isArray(atom)) {\n              return value.map(transformer);\n            } else {\n              return transformer(atom);\n            }\n          })(value);\n        });\n        break;\n      }\n      case '$all': {\n        const arr = constraint[key];\n        if (!Array.isArray(arr)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value');\n        }\n        answer[key] = arr.map(transformInteriorAtom);\n\n        const values = answer[key];\n        if (isAnyValueRegex(values) && !isAllValuesRegexOrNone(values)) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            'All $all values must be of regex type or none: ' + values\n          );\n        }\n\n        break;\n      }\n      case '$regex':\n        var s = constraint[key];\n        if (typeof s !== 'string') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad regex: ' + s);\n        }\n        answer[key] = s;\n        break;\n\n      case '$containedBy': {\n        const arr = constraint[key];\n        if (!Array.isArray(arr)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $containedBy: should be an array`);\n        }\n        answer.$elemMatch = {\n          $nin: arr.map(transformer),\n        };\n        break;\n      }\n      case '$options':\n        answer[key] = constraint[key];\n        break;\n\n      case '$text': {\n        const search = constraint[key].$search;\n        if (typeof search !== 'object') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $search, should be object`);\n        }\n        if (!search.$term || typeof search.$term !== 'string') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $term, should be string`);\n        } else {\n          answer[key] = {\n            $search: search.$term,\n          };\n        }\n        if (search.$language && typeof search.$language !== 'string') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $language, should be string`);\n        } else if (search.$language) {\n          answer[key].$language = search.$language;\n        }\n        if (search.$caseSensitive && typeof search.$caseSensitive !== 'boolean') {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `bad $text: $caseSensitive, should be boolean`\n          );\n        } else if (search.$caseSensitive) {\n          answer[key].$caseSensitive = search.$caseSensitive;\n        }\n        if (search.$diacriticSensitive && typeof search.$diacriticSensitive !== 'boolean') {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            `bad $text: $diacriticSensitive, should be boolean`\n          );\n        } else if (search.$diacriticSensitive) {\n          answer[key].$diacriticSensitive = search.$diacriticSensitive;\n        }\n        break;\n      }\n      case '$nearSphere': {\n        const point = constraint[key];\n        if (count) {\n          answer.$geoWithin = {\n            $centerSphere: [[point.longitude, point.latitude], constraint.$maxDistance],\n          };\n        } else {\n          answer[key] = [point.longitude, point.latitude];\n        }\n        break;\n      }\n      case '$maxDistance': {\n        if (count) {\n          break;\n        }\n        answer[key] = constraint[key];\n        break;\n      }\n      // The SDKs don't seem to use these but they are documented in the\n      // REST API docs.\n      case '$maxDistanceInRadians':\n        answer['$maxDistance'] = constraint[key];\n        break;\n      case '$maxDistanceInMiles':\n        answer['$maxDistance'] = constraint[key] / 3959;\n        break;\n      case '$maxDistanceInKilometers':\n        answer['$maxDistance'] = constraint[key] / 6371;\n        break;\n\n      case '$select':\n      case '$dontSelect':\n        throw new Parse.Error(\n          Parse.Error.COMMAND_UNAVAILABLE,\n          'the ' + key + ' constraint is not supported yet'\n        );\n\n      case '$within':\n        var box = constraint[key]['$box'];\n        if (!box || box.length != 2) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'malformatted $within arg');\n        }\n        answer[key] = {\n          $box: [\n            [box[0].longitude, box[0].latitude],\n            [box[1].longitude, box[1].latitude],\n          ],\n        };\n        break;\n\n      case '$geoWithin': {\n        const polygon = constraint[key]['$polygon'];\n        const centerSphere = constraint[key]['$centerSphere'];\n        if (polygon !== undefined) {\n          let points;\n          if (typeof polygon === 'object' && polygon.__type === 'Polygon') {\n            if (!polygon.coordinates || polygon.coordinates.length < 3) {\n              throw new Parse.Error(\n                Parse.Error.INVALID_JSON,\n                'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs'\n              );\n            }\n            points = polygon.coordinates;\n          } else if (Array.isArray(polygon)) {\n            if (polygon.length < 3) {\n              throw new Parse.Error(\n                Parse.Error.INVALID_JSON,\n                'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'\n              );\n            }\n            points = polygon;\n          } else {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              \"bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint's\"\n            );\n          }\n          points = points.map(point => {\n            if (Array.isArray(point) && point.length === 2) {\n              Parse.GeoPoint._validate(point[1], point[0]);\n              return point;\n            }\n            if (!GeoPointCoder.isValidJSON(point)) {\n              throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value');\n            } else {\n              Parse.GeoPoint._validate(point.latitude, point.longitude);\n            }\n            return [point.longitude, point.latitude];\n          });\n          answer[key] = {\n            $polygon: points,\n          };\n        } else if (centerSphere !== undefined) {\n          if (!Array.isArray(centerSphere) || centerSphere.length < 2) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance'\n            );\n          }\n          // Get point, convert to geo point if necessary and validate\n          let point = centerSphere[0];\n          if (Array.isArray(point) && point.length === 2) {\n            point = new Parse.GeoPoint(point[1], point[0]);\n          } else if (!GeoPointCoder.isValidJSON(point)) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              'bad $geoWithin value; $centerSphere geo point invalid'\n            );\n          }\n          Parse.GeoPoint._validate(point.latitude, point.longitude);\n          // Get distance and validate\n          const distance = centerSphere[1];\n          if (isNaN(distance) || distance < 0) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              'bad $geoWithin value; $centerSphere distance invalid'\n            );\n          }\n          answer[key] = {\n            $centerSphere: [[point.longitude, point.latitude], distance],\n          };\n        }\n        break;\n      }\n      case '$geoIntersects': {\n        const point = constraint[key]['$point'];\n        if (!GeoPointCoder.isValidJSON(point)) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            'bad $geoIntersect value; $point should be GeoPoint'\n          );\n        } else {\n          Parse.GeoPoint._validate(point.latitude, point.longitude);\n        }\n        answer[key] = {\n          $geometry: {\n            type: 'Point',\n            coordinates: [point.longitude, point.latitude],\n          },\n        };\n        break;\n      }\n      default:\n        if (key.match(/^\\$+/)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad constraint: ' + key);\n        }\n        return CannotTransform;\n    }\n  }\n  return answer;\n}\n\n// Transforms an update operator from REST format to mongo format.\n// To be transformed, the input should have an __op field.\n// If flatten is true, this will flatten operators to their static\n// data format. For example, an increment of 2 would simply become a\n// 2.\n// The output for a non-flattened operator is a hash with __op being\n// the mongo op, and arg being the argument.\n// The output for a flattened operator is just a value.\n// Returns undefined if this should be a no-op.\n\nfunction transformUpdateOperator({ __op, amount, objects }, flatten) {\n  switch (__op) {\n    case 'Delete':\n      if (flatten) {\n        return undefined;\n      } else {\n        return { __op: '$unset', arg: '' };\n      }\n\n    case 'Increment':\n      if (typeof amount !== 'number') {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'incrementing must provide a number');\n      }\n      if (flatten) {\n        return amount;\n      } else {\n        return { __op: '$inc', arg: amount };\n      }\n\n    case 'SetOnInsert':\n      if (flatten) {\n        return amount;\n      } else {\n        return { __op: '$setOnInsert', arg: amount };\n      }\n\n    case 'Add':\n    case 'AddUnique':\n      if (!Array.isArray(objects)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n      }\n      var toAdd = objects.map(transformInteriorAtom);\n      if (flatten) {\n        return toAdd;\n      } else {\n        var mongoOp = {\n          Add: '$push',\n          AddUnique: '$addToSet',\n        }[__op];\n        return { __op: mongoOp, arg: { $each: toAdd } };\n      }\n\n    case 'Remove':\n      if (!Array.isArray(objects)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to remove must be an array');\n      }\n      var toRemove = objects.map(transformInteriorAtom);\n      if (flatten) {\n        return [];\n      } else {\n        return { __op: '$pullAll', arg: toRemove };\n      }\n\n    default:\n      throw new Parse.Error(\n        Parse.Error.COMMAND_UNAVAILABLE,\n        `The ${__op} operator is not supported yet.`\n      );\n  }\n}\nfunction mapValues(object, iterator) {\n  const result = {};\n  Object.keys(object).forEach(key => {\n    result[key] = iterator(object[key]);\n  });\n  return result;\n}\n\nconst nestedMongoObjectToNestedParseObject = mongoObject => {\n  switch (typeof mongoObject) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n      return mongoObject;\n    case 'symbol':\n    case 'function':\n      throw 'bad value in nestedMongoObjectToNestedParseObject';\n    case 'object':\n      if (mongoObject === null) {\n        return null;\n      }\n      if (Array.isArray(mongoObject)) {\n        return mongoObject.map(nestedMongoObjectToNestedParseObject);\n      }\n\n      if (Utils.isDate(mongoObject)) {\n        return Parse._encode(mongoObject);\n      }\n\n      if (mongoObject instanceof mongodb.Long) {\n        return mongoObject.toNumber();\n      }\n\n      if (mongoObject instanceof mongodb.Double) {\n        return mongoObject.value;\n      }\n\n      if (BytesCoder.isValidDatabaseObject(mongoObject)) {\n        return BytesCoder.databaseToJSON(mongoObject);\n      }\n\n      if (\n        Object.prototype.hasOwnProperty.call(mongoObject, '__type') &&\n        mongoObject.__type == 'Date' &&\n        Utils.isDate(mongoObject.iso)\n      ) {\n        mongoObject.iso = mongoObject.iso.toJSON();\n        return mongoObject;\n      }\n\n      return mapValues(mongoObject, nestedMongoObjectToNestedParseObject);\n    default:\n      throw 'unknown js type';\n  }\n};\n\nconst transformPointerString = (schema, field, pointerString) => {\n  const objData = pointerString.split('$');\n  if (objData[0] !== schema.fields[field].targetClass) {\n    throw 'pointer to incorrect className';\n  }\n  return {\n    __type: 'Pointer',\n    className: objData[0],\n    objectId: objData[1],\n  };\n};\n\n// Converts from a mongo-format object to a REST-format object.\n// Does not strip out anything based on a lack of authentication.\nconst mongoObjectToParseObject = (className, mongoObject, schema) => {\n  switch (typeof mongoObject) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n      return mongoObject;\n    case 'symbol':\n    case 'function':\n      throw 'bad value in mongoObjectToParseObject';\n    case 'object': {\n      if (mongoObject === null) {\n        return null;\n      }\n      if (Array.isArray(mongoObject)) {\n        return mongoObject.map(nestedMongoObjectToNestedParseObject);\n      }\n\n      if (Utils.isDate(mongoObject)) {\n        return Parse._encode(mongoObject);\n      }\n\n      if (mongoObject instanceof mongodb.Long) {\n        return mongoObject.toNumber();\n      }\n\n      if (mongoObject instanceof mongodb.Double) {\n        return mongoObject.value;\n      }\n\n      if (BytesCoder.isValidDatabaseObject(mongoObject)) {\n        return BytesCoder.databaseToJSON(mongoObject);\n      }\n\n      const restObject = {};\n      if (mongoObject._rperm || mongoObject._wperm) {\n        restObject._rperm = mongoObject._rperm || [];\n        restObject._wperm = mongoObject._wperm || [];\n        delete mongoObject._rperm;\n        delete mongoObject._wperm;\n      }\n\n      for (var key in mongoObject) {\n        switch (key) {\n          case '_id':\n            restObject['objectId'] = '' + mongoObject[key];\n            break;\n          case '_hashed_password':\n            restObject._hashed_password = mongoObject[key];\n            break;\n          case '_acl':\n            break;\n          case '_email_verify_token':\n          case '_perishable_token':\n          case '_perishable_token_expires_at':\n          case '_password_changed_at':\n          case '_tombstone':\n          case '_email_verify_token_expires_at':\n          case '_account_lockout_expires_at':\n          case '_failed_login_count':\n          case '_password_history':\n            // Those keys will be deleted if needed in the DB Controller\n            restObject[key] = mongoObject[key];\n            break;\n          case '_session_token':\n            restObject['sessionToken'] = mongoObject[key];\n            break;\n          case 'updatedAt':\n          case '_updated_at':\n            restObject['updatedAt'] = Parse._encode(new Date(mongoObject[key])).iso;\n            break;\n          case 'createdAt':\n          case '_created_at':\n            restObject['createdAt'] = Parse._encode(new Date(mongoObject[key])).iso;\n            break;\n          case 'expiresAt':\n          case '_expiresAt':\n            restObject['expiresAt'] = Parse._encode(new Date(mongoObject[key]));\n            break;\n          case 'lastUsed':\n          case '_last_used':\n            restObject['lastUsed'] = Parse._encode(new Date(mongoObject[key])).iso;\n            break;\n          case 'timesUsed':\n          case 'times_used':\n            restObject['timesUsed'] = mongoObject[key];\n            break;\n          case 'authData':\n            if (className === '_User') {\n              log.warn(\n                'ignoring authData in _User as this key is reserved to be synthesized of `_auth_data_*` keys'\n              );\n            } else {\n              restObject['authData'] = mongoObject[key];\n            }\n            break;\n          default:\n            // Check other auth data keys\n            var authDataMatch = key.match(/^_auth_data_([a-zA-Z0-9_]+)$/);\n            if (authDataMatch && className === '_User') {\n              var provider = authDataMatch[1];\n              restObject['authData'] = restObject['authData'] || {};\n              restObject['authData'][provider] = mongoObject[key];\n              break;\n            }\n\n            if (key.indexOf('_p_') == 0) {\n              var newKey = key.substring(3);\n              if (!schema.fields[newKey]) {\n                log.info(\n                  'transform.js',\n                  'Found a pointer column not in the schema, dropping it.',\n                  className,\n                  newKey\n                );\n                break;\n              }\n              if (schema.fields[newKey].type !== 'Pointer') {\n                log.info(\n                  'transform.js',\n                  'Found a pointer in a non-pointer column, dropping it.',\n                  className,\n                  key\n                );\n                break;\n              }\n              if (mongoObject[key] === null) {\n                break;\n              }\n              restObject[newKey] = transformPointerString(schema, newKey, mongoObject[key]);\n              break;\n            } else if (key[0] == '_' && key != '__type') {\n              throw 'bad key in untransform: ' + key;\n            } else {\n              var value = mongoObject[key];\n              if (\n                schema.fields[key] &&\n                schema.fields[key].type === 'File' &&\n                FileCoder.isValidDatabaseObject(value)\n              ) {\n                restObject[key] = FileCoder.databaseToJSON(value);\n                break;\n              }\n              if (\n                schema.fields[key] &&\n                schema.fields[key].type === 'GeoPoint' &&\n                GeoPointCoder.isValidDatabaseObject(value)\n              ) {\n                restObject[key] = GeoPointCoder.databaseToJSON(value);\n                break;\n              }\n              if (\n                schema.fields[key] &&\n                schema.fields[key].type === 'Polygon' &&\n                PolygonCoder.isValidDatabaseObject(value)\n              ) {\n                restObject[key] = PolygonCoder.databaseToJSON(value);\n                break;\n              }\n              if (\n                schema.fields[key] &&\n                schema.fields[key].type === 'Bytes' &&\n                BytesCoder.isValidDatabaseObject(value)\n              ) {\n                restObject[key] = BytesCoder.databaseToJSON(value);\n                break;\n              }\n            }\n            restObject[key] = nestedMongoObjectToNestedParseObject(mongoObject[key]);\n        }\n      }\n\n      const relationFieldNames = Object.keys(schema.fields).filter(\n        fieldName => schema.fields[fieldName].type === 'Relation'\n      );\n      const relationFields = {};\n      relationFieldNames.forEach(relationFieldName => {\n        relationFields[relationFieldName] = {\n          __type: 'Relation',\n          className: schema.fields[relationFieldName].targetClass,\n        };\n      });\n\n      return { ...restObject, ...relationFields };\n    }\n    default:\n      throw 'unknown js type';\n  }\n};\n\nvar DateCoder = {\n  JSONToDatabase(json) {\n    return new Date(json.iso);\n  },\n\n  isValidJSON(value) {\n    return typeof value === 'object' && value !== null && value.__type === 'Date';\n  },\n};\n\nvar BytesCoder = {\n  base64Pattern: new RegExp('^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$'),\n  isBase64Value(object) {\n    if (typeof object !== 'string') {\n      return false;\n    }\n    return this.base64Pattern.test(object);\n  },\n\n  databaseToJSON(object) {\n    let value;\n    if (this.isBase64Value(object)) {\n      value = object;\n    } else {\n      value = object.buffer.toString('base64');\n    }\n    return {\n      __type: 'Bytes',\n      base64: value,\n    };\n  },\n\n  isValidDatabaseObject(object) {\n    return object instanceof mongodb.Binary || this.isBase64Value(object);\n  },\n\n  JSONToDatabase(json) {\n    return new mongodb.Binary(Buffer.from(json.base64, 'base64'));\n  },\n\n  isValidJSON(value) {\n    return typeof value === 'object' && value !== null && value.__type === 'Bytes';\n  },\n};\n\nvar GeoPointCoder = {\n  databaseToJSON(object) {\n    return {\n      __type: 'GeoPoint',\n      latitude: object[1],\n      longitude: object[0],\n    };\n  },\n\n  isValidDatabaseObject(object) {\n    return Array.isArray(object) && object.length == 2;\n  },\n\n  JSONToDatabase(json) {\n    return [json.longitude, json.latitude];\n  },\n\n  isValidJSON(value) {\n    return typeof value === 'object' && value !== null && value.__type === 'GeoPoint';\n  },\n};\n\nvar PolygonCoder = {\n  databaseToJSON(object) {\n    // Convert lng/lat -> lat/lng\n    const coords = object.coordinates[0].map(coord => {\n      return [coord[1], coord[0]];\n    });\n    return {\n      __type: 'Polygon',\n      coordinates: coords,\n    };\n  },\n\n  isValidDatabaseObject(object) {\n    const coords = object.coordinates[0];\n    if (object.type !== 'Polygon' || !Array.isArray(coords)) {\n      return false;\n    }\n    for (let i = 0; i < coords.length; i++) {\n      const point = coords[i];\n      if (!GeoPointCoder.isValidDatabaseObject(point)) {\n        return false;\n      }\n      Parse.GeoPoint._validate(parseFloat(point[1]), parseFloat(point[0]));\n    }\n    return true;\n  },\n\n  JSONToDatabase(json) {\n    let coords = json.coordinates;\n    // Add first point to the end to close polygon\n    if (\n      coords[0][0] !== coords[coords.length - 1][0] ||\n      coords[0][1] !== coords[coords.length - 1][1]\n    ) {\n      coords.push(coords[0]);\n    }\n    const unique = coords.filter((item, index, ar) => {\n      let foundIndex = -1;\n      for (let i = 0; i < ar.length; i += 1) {\n        const pt = ar[i];\n        if (pt[0] === item[0] && pt[1] === item[1]) {\n          foundIndex = i;\n          break;\n        }\n      }\n      return foundIndex === index;\n    });\n    if (unique.length < 3) {\n      throw new Parse.Error(\n        Parse.Error.INTERNAL_SERVER_ERROR,\n        'GeoJSON: Loop must have at least 3 different vertices'\n      );\n    }\n    // Convert lat/long -> long/lat\n    coords = coords.map(coord => {\n      return [coord[1], coord[0]];\n    });\n    return { type: 'Polygon', coordinates: [coords] };\n  },\n\n  isValidJSON(value) {\n    return typeof value === 'object' && value !== null && value.__type === 'Polygon';\n  },\n};\n\nvar FileCoder = {\n  databaseToJSON(object) {\n    return {\n      __type: 'File',\n      name: object,\n    };\n  },\n\n  isValidDatabaseObject(object) {\n    return typeof object === 'string';\n  },\n\n  JSONToDatabase(json) {\n    return json.name;\n  },\n\n  isValidJSON(value) {\n    return typeof value === 'object' && value !== null && value.__type === 'File';\n  },\n};\n\nmodule.exports = {\n  transformKey,\n  parseObjectToMongoObjectForCreate,\n  transformUpdate,\n  transformWhere,\n  mongoObjectToParseObject,\n  transformConstraint,\n  transformPointerString,\n};\n"],"mappings":"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","ignoreList":[]}