@beiguancyc/parse-server 9.9.0-ruixiang.1

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

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const mongodb = require('mongodb');
+const Collection = mongodb.Collection;
+class MongoCollection {
+  constructor(mongoCollection) {
+    this._mongoCollection = mongoCollection;
+  }
+
+  // Does a find with "smart indexing".
+  // Currently this just means, if it needs a geoindex and there is
+  // none, then build the geoindex.
+  // This could be improved a lot but it's not clear if that's a good
+  // idea. Or even if this behavior is a good idea.
+  find(query, {
+    skip,
+    limit,
+    sort,
+    keys,
+    maxTimeMS,
+    batchSize,
+    readPreference,
+    hint,
+    caseInsensitive,
+    explain,
+    comment
+  } = {}) {
+    // Support for Full Text Search - $text
+    if (keys && keys.$score) {
+      delete keys.$score;
+      keys.score = {
+        $meta: 'textScore'
+      };
+    }
+    return this._rawFind(query, {
+      skip,
+      limit,
+      sort,
+      keys,
+      maxTimeMS,
+      batchSize,
+      readPreference,
+      hint,
+      caseInsensitive,
+      explain,
+      comment
+    }).catch(error => {
+      // Check for "no geoindex" error
+      if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {
+        throw error;
+      }
+      // Figure out what key needs an index
+      const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];
+      if (!key) {
+        throw error;
+      }
+      var index = {};
+      index[key] = '2d';
+      return this._mongoCollection.createIndex(index)
+      // Retry, but just once.
+      .then(() => this._rawFind(query, {
+        skip,
+        limit,
+        sort,
+        keys,
+        maxTimeMS,
+        batchSize,
+        readPreference,
+        hint,
+        caseInsensitive,
+        explain,
+        comment
+      }));
+    });
+  }
+
+  /**
+   * Collation to support case insensitive queries
+   */
+  static caseInsensitiveCollation() {
+    return {
+      locale: 'en_US',
+      strength: 2
+    };
+  }
+  _rawFind(query, {
+    skip,
+    limit,
+    sort,
+    keys,
+    maxTimeMS,
+    batchSize,
+    readPreference,
+    hint,
+    caseInsensitive,
+    explain,
+    comment
+  } = {}) {
+    let findOperation = this._mongoCollection.find(query, {
+      skip,
+      limit,
+      sort,
+      readPreference,
+      hint,
+      comment,
+      batchSize
+    });
+    if (keys) {
+      findOperation = findOperation.project(keys);
+    }
+    if (caseInsensitive) {
+      findOperation = findOperation.collation(MongoCollection.caseInsensitiveCollation());
+    }
+    if (maxTimeMS) {
+      findOperation = findOperation.maxTimeMS(maxTimeMS);
+    }
+    return explain ? findOperation.explain(explain) : findOperation.toArray();
+  }
+  count(query, {
+    skip,
+    limit,
+    sort,
+    maxTimeMS,
+    readPreference,
+    hint,
+    comment
+  } = {}) {
+    // If query is empty, then use estimatedDocumentCount instead.
+    // This is due to countDocuments performing a scan,
+    // which greatly increases execution time when being run on large collections.
+    // See https://github.com/Automattic/mongoose/issues/6713 for more info regarding this problem.
+    if (typeof query !== 'object' || !Object.keys(query).length) {
+      return this._mongoCollection.estimatedDocumentCount({
+        maxTimeMS
+      });
+    }
+    const countOperation = this._mongoCollection.countDocuments(query, {
+      skip,
+      limit,
+      sort,
+      maxTimeMS,
+      readPreference,
+      hint,
+      comment
+    });
+    return countOperation;
+  }
+  distinct(field, query) {
+    return this._mongoCollection.distinct(field, query);
+  }
+  aggregate(pipeline, {
+    maxTimeMS,
+    batchSize,
+    readPreference,
+    hint,
+    explain,
+    comment
+  } = {}) {
+    return this._mongoCollection.aggregate(pipeline, {
+      maxTimeMS,
+      batchSize,
+      readPreference,
+      hint,
+      explain,
+      comment
+    }).toArray();
+  }
+  insertOne(object, session) {
+    return this._mongoCollection.insertOne(object, {
+      session
+    });
+  }
+
+  // Atomically updates data in the database for a single (first) object that matched the query
+  // If there is nothing that matches the query - does insert
+  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.
+  upsertOne(query, update, session) {
+    return this._mongoCollection.updateOne(query, update, {
+      upsert: true,
+      session
+    });
+  }
+  updateOne(query, update) {
+    return this._mongoCollection.updateOne(query, update);
+  }
+  updateMany(query, update, session) {
+    return this._mongoCollection.updateMany(query, update, {
+      session
+    });
+  }
+  deleteMany(query, session) {
+    return this._mongoCollection.deleteMany(query, {
+      session
+    });
+  }
+  _ensureSparseUniqueIndexInBackground(indexRequest) {
+    return this._mongoCollection.createIndex(indexRequest, {
+      unique: true,
+      background: true,
+      sparse: true
+    });
+  }
+  drop() {
+    return this._mongoCollection.drop();
+  }
+}
+exports.default = MongoCollection;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mongodb","require","Collection","MongoCollection","constructor","mongoCollection","_mongoCollection","find","query","skip","limit","sort","keys","maxTimeMS","batchSize","readPreference","hint","caseInsensitive","explain","comment","$score","score","$meta","_rawFind","catch","error","code","message","match","key","index","createIndex","then","caseInsensitiveCollation","locale","strength","findOperation","project","collation","toArray","count","Object","length","estimatedDocumentCount","countOperation","countDocuments","distinct","field","aggregate","pipeline","insertOne","object","session","upsertOne","update","updateOne","upsert","updateMany","deleteMany","_ensureSparseUniqueIndexInBackground","indexRequest","unique","background","sparse","drop","exports","default"],"sources":["../../../../src/Adapters/Storage/Mongo/MongoCollection.js"],"sourcesContent":["const mongodb = require('mongodb');\nconst Collection = mongodb.Collection;\n\nexport default class MongoCollection {\n  _mongoCollection: Collection;\n\n  constructor(mongoCollection: Collection) {\n    this._mongoCollection = mongoCollection;\n  }\n\n  // Does a find with \"smart indexing\".\n  // Currently this just means, if it needs a geoindex and there is\n  // none, then build the geoindex.\n  // This could be improved a lot but it's not clear if that's a good\n  // idea. Or even if this behavior is a good idea.\n  find(\n    query,\n    {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    } = {}\n  ) {\n    // Support for Full Text Search - $text\n    if (keys && keys.$score) {\n      delete keys.$score;\n      keys.score = { $meta: 'textScore' };\n    }\n    return this._rawFind(query, {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    }).catch(error => {\n      // Check for \"no geoindex\" error\n      if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {\n        throw error;\n      }\n      // Figure out what key needs an index\n      const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];\n      if (!key) {\n        throw error;\n      }\n\n      var index = {};\n      index[key] = '2d';\n      return (\n        this._mongoCollection\n          .createIndex(index)\n          // Retry, but just once.\n          .then(() =>\n            this._rawFind(query, {\n              skip,\n              limit,\n              sort,\n              keys,\n              maxTimeMS,\n              batchSize,\n              readPreference,\n              hint,\n              caseInsensitive,\n              explain,\n              comment,\n            })\n          )\n      );\n    });\n  }\n\n  /**\n   * Collation to support case insensitive queries\n   */\n  static caseInsensitiveCollation() {\n    return { locale: 'en_US', strength: 2 };\n  }\n\n  _rawFind(\n    query,\n    {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    } = {}\n  ) {\n    let findOperation = this._mongoCollection.find(query, {\n      skip,\n      limit,\n      sort,\n      readPreference,\n      hint,\n      comment,\n      batchSize,\n    });\n\n    if (keys) {\n      findOperation = findOperation.project(keys);\n    }\n\n    if (caseInsensitive) {\n      findOperation = findOperation.collation(MongoCollection.caseInsensitiveCollation());\n    }\n\n    if (maxTimeMS) {\n      findOperation = findOperation.maxTimeMS(maxTimeMS);\n    }\n\n    return explain ? findOperation.explain(explain) : findOperation.toArray();\n  }\n\n  count(query, { skip, limit, sort, maxTimeMS, readPreference, hint, comment } = {}) {\n    // If query is empty, then use estimatedDocumentCount instead.\n    // This is due to countDocuments performing a scan,\n    // which greatly increases execution time when being run on large collections.\n    // See https://github.com/Automattic/mongoose/issues/6713 for more info regarding this problem.\n    if (typeof query !== 'object' || !Object.keys(query).length) {\n      return this._mongoCollection.estimatedDocumentCount({\n        maxTimeMS,\n      });\n    }\n\n    const countOperation = this._mongoCollection.countDocuments(query, {\n      skip,\n      limit,\n      sort,\n      maxTimeMS,\n      readPreference,\n      hint,\n      comment,\n    });\n\n    return countOperation;\n  }\n\n  distinct(field, query) {\n    return this._mongoCollection.distinct(field, query);\n  }\n\n  aggregate(pipeline, { maxTimeMS, batchSize, readPreference, hint, explain, comment } = {}) {\n    return this._mongoCollection\n      .aggregate(pipeline, { maxTimeMS, batchSize, readPreference, hint, explain, comment })\n      .toArray();\n  }\n\n  insertOne(object, session) {\n    return this._mongoCollection.insertOne(object, { session });\n  }\n\n  // Atomically updates data in the database for a single (first) object that matched the query\n  // If there is nothing that matches the query - does insert\n  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.\n  upsertOne(query, update, session) {\n    return this._mongoCollection.updateOne(query, update, {\n      upsert: true,\n      session,\n    });\n  }\n\n  updateOne(query, update) {\n    return this._mongoCollection.updateOne(query, update);\n  }\n\n  updateMany(query, update, session) {\n    return this._mongoCollection.updateMany(query, update, { session });\n  }\n\n  deleteMany(query, session) {\n    return this._mongoCollection.deleteMany(query, { session });\n  }\n\n  _ensureSparseUniqueIndexInBackground(indexRequest) {\n    return this._mongoCollection.createIndex(indexRequest, {\n      unique: true,\n      background: true,\n      sparse: true,\n    });\n  }\n\n  drop() {\n    return this._mongoCollection.drop();\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,334 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _MongoCollection = _interopRequireDefault(require("./MongoCollection"));
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function mongoFieldToParseSchemaField(type) {
+  if (type[0] === '*') {
+    return {
+      type: 'Pointer',
+      targetClass: type.slice(1)
+    };
+  }
+  if (type.startsWith('relation<')) {
+    return {
+      type: 'Relation',
+      targetClass: type.slice('relation<'.length, type.length - 1)
+    };
+  }
+  switch (type) {
+    case 'number':
+      return {
+        type: 'Number'
+      };
+    case 'string':
+      return {
+        type: 'String'
+      };
+    case 'boolean':
+      return {
+        type: 'Boolean'
+      };
+    case 'date':
+      return {
+        type: 'Date'
+      };
+    case 'map':
+    case 'object':
+      return {
+        type: 'Object'
+      };
+    case 'array':
+      return {
+        type: 'Array'
+      };
+    case 'geopoint':
+      return {
+        type: 'GeoPoint'
+      };
+    case 'file':
+      return {
+        type: 'File'
+      };
+    case 'bytes':
+      return {
+        type: 'Bytes'
+      };
+    case 'polygon':
+      return {
+        type: 'Polygon'
+      };
+  }
+}
+const nonFieldSchemaKeys = ['_id', '_metadata', '_client_permissions'];
+function mongoSchemaFieldsToParseSchemaFields(schema) {
+  var fieldNames = Object.keys(schema).filter(key => nonFieldSchemaKeys.indexOf(key) === -1);
+  var response = fieldNames.reduce((obj, fieldName) => {
+    obj[fieldName] = mongoFieldToParseSchemaField(schema[fieldName]);
+    if (schema._metadata && schema._metadata.fields_options && schema._metadata.fields_options[fieldName]) {
+      obj[fieldName] = Object.assign({}, obj[fieldName], schema._metadata.fields_options[fieldName]);
+    }
+    return obj;
+  }, {});
+  response.ACL = {
+    type: 'ACL'
+  };
+  response.createdAt = {
+    type: 'Date'
+  };
+  response.updatedAt = {
+    type: 'Date'
+  };
+  response.objectId = {
+    type: 'String'
+  };
+  return response;
+}
+const emptyCLPS = Object.freeze({
+  find: {},
+  count: {},
+  get: {},
+  create: {},
+  update: {},
+  delete: {},
+  addField: {},
+  protectedFields: {}
+});
+const defaultCLPS = Object.freeze({
+  ACL: {
+    '*': {
+      read: true,
+      write: true
+    }
+  },
+  find: {
+    '*': true
+  },
+  count: {
+    '*': true
+  },
+  get: {
+    '*': true
+  },
+  create: {
+    '*': true
+  },
+  update: {
+    '*': true
+  },
+  delete: {
+    '*': true
+  },
+  addField: {
+    '*': true
+  },
+  protectedFields: {
+    '*': []
+  }
+});
+function mongoSchemaToParseSchema(mongoSchema) {
+  let clps = defaultCLPS;
+  let indexes = {};
+  if (mongoSchema._metadata) {
+    if (mongoSchema._metadata.class_permissions) {
+      clps = {
+        ...emptyCLPS,
+        ...mongoSchema._metadata.class_permissions
+      };
+    }
+    if (mongoSchema._metadata.indexes) {
+      indexes = {
+        ...mongoSchema._metadata.indexes
+      };
+    }
+  }
+  return {
+    className: mongoSchema._id,
+    fields: mongoSchemaFieldsToParseSchemaFields(mongoSchema),
+    classLevelPermissions: clps,
+    indexes: indexes
+  };
+}
+function _mongoSchemaQueryFromNameQuery(name, query) {
+  const object = {
+    _id: name
+  };
+  if (query) {
+    Object.keys(query).forEach(key => {
+      object[key] = query[key];
+    });
+  }
+  return object;
+}
+
+// Returns a type suitable for inserting into mongo _SCHEMA collection.
+// Does no validation. That is expected to be done in Parse Server.
+function parseFieldTypeToMongoFieldType({
+  type,
+  targetClass
+}) {
+  switch (type) {
+    case 'Pointer':
+      return `*${targetClass}`;
+    case 'Relation':
+      return `relation<${targetClass}>`;
+    case 'Number':
+      return 'number';
+    case 'String':
+      return 'string';
+    case 'Boolean':
+      return 'boolean';
+    case 'Date':
+      return 'date';
+    case 'Object':
+      return 'object';
+    case 'Array':
+      return 'array';
+    case 'GeoPoint':
+      return 'geopoint';
+    case 'File':
+      return 'file';
+    case 'Bytes':
+      return 'bytes';
+    case 'Polygon':
+      return 'polygon';
+  }
+}
+class MongoSchemaCollection {
+  constructor(collection) {
+    this._collection = collection;
+  }
+  _fetchAllSchemasFrom_SCHEMA() {
+    return this._collection._rawFind({}).then(schemas => schemas.map(mongoSchemaToParseSchema));
+  }
+  _fetchOneSchemaFrom_SCHEMA(name) {
+    return this._collection._rawFind(_mongoSchemaQueryFromNameQuery(name), {
+      limit: 1
+    }).then(results => {
+      if (results.length === 1) {
+        return mongoSchemaToParseSchema(results[0]);
+      } else {
+        throw undefined;
+      }
+    });
+  }
+
+  // Atomically find and delete an object based on query.
+  findAndDeleteSchema(name) {
+    return this._collection._mongoCollection.findOneAndDelete(_mongoSchemaQueryFromNameQuery(name));
+  }
+  insertSchema(schema) {
+    return this._collection.insertOne(schema).then(() => mongoSchemaToParseSchema(schema)).catch(error => {
+      if (error.code === 11000) {
+        //Mongo's duplicate key error
+        throw new _node.default.Error(_node.default.Error.DUPLICATE_VALUE, 'Class already exists.');
+      } else {
+        throw error;
+      }
+    });
+  }
+  updateSchema(name, update) {
+    return this._collection.updateOne(_mongoSchemaQueryFromNameQuery(name), update);
+  }
+  upsertSchema(name, query, update) {
+    return this._collection.upsertOne(_mongoSchemaQueryFromNameQuery(name, query), update);
+  }
+
+  // Add a field to the schema. If database does not support the field
+  // type (e.g. mongo doesn't support more than one GeoPoint in a class) reject with an "Incorrect Type"
+  // Parse error with a desciptive message. If the field already exists, this function must
+  // not modify the schema, and must reject with DUPLICATE_VALUE error.
+  // If this is called for a class that doesn't exist, this function must create that class.
+
+  // TODO: throw an error if an unsupported field type is passed. Deciding whether a type is supported
+  // should be the job of the adapter. Some adapters may not support GeoPoint at all. Others may
+  // Support additional types that Mongo doesn't, like Money, or something.
+
+  // TODO: don't spend an extra query on finding the schema if the type we are trying to add isn't a GeoPoint.
+  addFieldIfNotExists(className, fieldName, fieldType) {
+    return this._fetchOneSchemaFrom_SCHEMA(className).then(schema => {
+      // If a field with this name already exists, it will be handled elsewhere.
+      if (schema.fields[fieldName] !== undefined) {
+        return;
+      }
+      // The schema exists. Check for existing GeoPoints.
+      if (fieldType.type === 'GeoPoint') {
+        // Make sure there are not other geopoint fields
+        if (Object.keys(schema.fields).some(existingField => schema.fields[existingField].type === 'GeoPoint')) {
+          throw new _node.default.Error(_node.default.Error.INCORRECT_TYPE, 'MongoDB only supports one GeoPoint field in a class.');
+        }
+      }
+      return;
+    }, error => {
+      // If error is undefined, the schema doesn't exist, and we can create the schema with the field.
+      // If some other error, reject with it.
+      if (error === undefined) {
+        return;
+      }
+      throw error;
+    }).then(() => {
+      const {
+        type,
+        targetClass,
+        ...fieldOptions
+      } = fieldType;
+      // We use $exists and $set to avoid overwriting the field type if it
+      // already exists. (it could have added inbetween the last query and the update)
+      if (fieldOptions && Object.keys(fieldOptions).length > 0) {
+        return this.upsertSchema(className, {
+          [fieldName]: {
+            $exists: false
+          }
+        }, {
+          $set: {
+            [fieldName]: parseFieldTypeToMongoFieldType({
+              type,
+              targetClass
+            }),
+            [`_metadata.fields_options.${fieldName}`]: fieldOptions
+          }
+        });
+      } else {
+        return this.upsertSchema(className, {
+          [fieldName]: {
+            $exists: false
+          }
+        }, {
+          $set: {
+            [fieldName]: parseFieldTypeToMongoFieldType({
+              type,
+              targetClass
+            })
+          }
+        });
+      }
+    });
+  }
+  async updateFieldOptions(className, fieldName, fieldType) {
+    const {
+      ...fieldOptions
+    } = fieldType;
+    delete fieldOptions.type;
+    delete fieldOptions.targetClass;
+    await this.upsertSchema(className, {
+      [fieldName]: {
+        $exists: true
+      }
+    }, {
+      $set: {
+        [`_metadata.fields_options.${fieldName}`]: fieldOptions
+      }
+    });
+  }
+}
+
+// Exported for testing reasons and because we haven't moved all mongo schema format
+// related logic into the database adapter yet.
+MongoSchemaCollection._TESTmongoSchemaToParseSchema = mongoSchemaToParseSchema;
+MongoSchemaCollection.parseFieldTypeToMongoFieldType = parseFieldTypeToMongoFieldType;
+var _default = exports.default = MongoSchemaCollection;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_MongoCollection","_interopRequireDefault","require","_node","e","__esModule","default","mongoFieldToParseSchemaField","type","targetClass","slice","startsWith","length","nonFieldSchemaKeys","mongoSchemaFieldsToParseSchemaFields","schema","fieldNames","Object","keys","filter","key","indexOf","response","reduce","obj","fieldName","_metadata","fields_options","assign","ACL","createdAt","updatedAt","objectId","emptyCLPS","freeze","find","count","get","create","update","delete","addField","protectedFields","defaultCLPS","read","write","mongoSchemaToParseSchema","mongoSchema","clps","indexes","class_permissions","className","_id","fields","classLevelPermissions","_mongoSchemaQueryFromNameQuery","name","query","object","forEach","parseFieldTypeToMongoFieldType","MongoSchemaCollection","constructor","collection","_collection","_fetchAllSchemasFrom_SCHEMA","_rawFind","then","schemas","map","_fetchOneSchemaFrom_SCHEMA","limit","results","undefined","findAndDeleteSchema","_mongoCollection","findOneAndDelete","insertSchema","insertOne","catch","error","code","Parse","Error","DUPLICATE_VALUE","updateSchema","updateOne","upsertSchema","upsertOne","addFieldIfNotExists","fieldType","some","existingField","INCORRECT_TYPE","fieldOptions","$exists","$set","updateFieldOptions","_TESTmongoSchemaToParseSchema","_default","exports"],"sources":["../../../../src/Adapters/Storage/Mongo/MongoSchemaCollection.js"],"sourcesContent":["import MongoCollection from './MongoCollection';\nimport Parse from 'parse/node';\n\nfunction mongoFieldToParseSchemaField(type) {\n  if (type[0] === '*') {\n    return {\n      type: 'Pointer',\n      targetClass: type.slice(1),\n    };\n  }\n  if (type.startsWith('relation<')) {\n    return {\n      type: 'Relation',\n      targetClass: type.slice('relation<'.length, type.length - 1),\n    };\n  }\n  switch (type) {\n    case 'number':\n      return { type: 'Number' };\n    case 'string':\n      return { type: 'String' };\n    case 'boolean':\n      return { type: 'Boolean' };\n    case 'date':\n      return { type: 'Date' };\n    case 'map':\n    case 'object':\n      return { type: 'Object' };\n    case 'array':\n      return { type: 'Array' };\n    case 'geopoint':\n      return { type: 'GeoPoint' };\n    case 'file':\n      return { type: 'File' };\n    case 'bytes':\n      return { type: 'Bytes' };\n    case 'polygon':\n      return { type: 'Polygon' };\n  }\n}\n\nconst nonFieldSchemaKeys = ['_id', '_metadata', '_client_permissions'];\nfunction mongoSchemaFieldsToParseSchemaFields(schema) {\n  var fieldNames = Object.keys(schema).filter(key => nonFieldSchemaKeys.indexOf(key) === -1);\n  var response = fieldNames.reduce((obj, fieldName) => {\n    obj[fieldName] = mongoFieldToParseSchemaField(schema[fieldName]);\n    if (\n      schema._metadata &&\n      schema._metadata.fields_options &&\n      schema._metadata.fields_options[fieldName]\n    ) {\n      obj[fieldName] = Object.assign(\n        {},\n        obj[fieldName],\n        schema._metadata.fields_options[fieldName]\n      );\n    }\n    return obj;\n  }, {});\n  response.ACL = { type: 'ACL' };\n  response.createdAt = { type: 'Date' };\n  response.updatedAt = { type: 'Date' };\n  response.objectId = { type: 'String' };\n  return response;\n}\n\nconst emptyCLPS = Object.freeze({\n  find: {},\n  count: {},\n  get: {},\n  create: {},\n  update: {},\n  delete: {},\n  addField: {},\n  protectedFields: {},\n});\n\nconst defaultCLPS = Object.freeze({\n  ACL: {\n    '*': {\n      read: true,\n      write: true,\n    },\n  },\n  find: { '*': true },\n  count: { '*': true },\n  get: { '*': true },\n  create: { '*': true },\n  update: { '*': true },\n  delete: { '*': true },\n  addField: { '*': true },\n  protectedFields: { '*': [] },\n});\n\nfunction mongoSchemaToParseSchema(mongoSchema) {\n  let clps = defaultCLPS;\n  let indexes = {};\n  if (mongoSchema._metadata) {\n    if (mongoSchema._metadata.class_permissions) {\n      clps = { ...emptyCLPS, ...mongoSchema._metadata.class_permissions };\n    }\n    if (mongoSchema._metadata.indexes) {\n      indexes = { ...mongoSchema._metadata.indexes };\n    }\n  }\n  return {\n    className: mongoSchema._id,\n    fields: mongoSchemaFieldsToParseSchemaFields(mongoSchema),\n    classLevelPermissions: clps,\n    indexes: indexes,\n  };\n}\n\nfunction _mongoSchemaQueryFromNameQuery(name: string, query) {\n  const object = { _id: name };\n  if (query) {\n    Object.keys(query).forEach(key => {\n      object[key] = query[key];\n    });\n  }\n  return object;\n}\n\n// Returns a type suitable for inserting into mongo _SCHEMA collection.\n// Does no validation. That is expected to be done in Parse Server.\nfunction parseFieldTypeToMongoFieldType({ type, targetClass }) {\n  switch (type) {\n    case 'Pointer':\n      return `*${targetClass}`;\n    case 'Relation':\n      return `relation<${targetClass}>`;\n    case 'Number':\n      return 'number';\n    case 'String':\n      return 'string';\n    case 'Boolean':\n      return 'boolean';\n    case 'Date':\n      return 'date';\n    case 'Object':\n      return 'object';\n    case 'Array':\n      return 'array';\n    case 'GeoPoint':\n      return 'geopoint';\n    case 'File':\n      return 'file';\n    case 'Bytes':\n      return 'bytes';\n    case 'Polygon':\n      return 'polygon';\n  }\n}\n\nclass MongoSchemaCollection {\n  _collection: MongoCollection;\n\n  constructor(collection: MongoCollection) {\n    this._collection = collection;\n  }\n\n  _fetchAllSchemasFrom_SCHEMA() {\n    return this._collection._rawFind({}).then(schemas => schemas.map(mongoSchemaToParseSchema));\n  }\n\n  _fetchOneSchemaFrom_SCHEMA(name: string) {\n    return this._collection\n      ._rawFind(_mongoSchemaQueryFromNameQuery(name), { limit: 1 })\n      .then(results => {\n        if (results.length === 1) {\n          return mongoSchemaToParseSchema(results[0]);\n        } else {\n          throw undefined;\n        }\n      });\n  }\n\n  // Atomically find and delete an object based on query.\n  findAndDeleteSchema(name: string) {\n    return this._collection._mongoCollection.findOneAndDelete(_mongoSchemaQueryFromNameQuery(name));\n  }\n\n  insertSchema(schema: any) {\n    return this._collection\n      .insertOne(schema)\n      .then(() => mongoSchemaToParseSchema(schema))\n      .catch(error => {\n        if (error.code === 11000) {\n          //Mongo's duplicate key error\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Class already exists.');\n        } else {\n          throw error;\n        }\n      });\n  }\n\n  updateSchema(name: string, update) {\n    return this._collection.updateOne(_mongoSchemaQueryFromNameQuery(name), update);\n  }\n\n  upsertSchema(name: string, query: string, update) {\n    return this._collection.upsertOne(_mongoSchemaQueryFromNameQuery(name, query), update);\n  }\n\n  // Add a field to the schema. If database does not support the field\n  // type (e.g. mongo doesn't support more than one GeoPoint in a class) reject with an \"Incorrect Type\"\n  // Parse error with a desciptive message. If the field already exists, this function must\n  // not modify the schema, and must reject with DUPLICATE_VALUE error.\n  // If this is called for a class that doesn't exist, this function must create that class.\n\n  // TODO: throw an error if an unsupported field type is passed. Deciding whether a type is supported\n  // should be the job of the adapter. Some adapters may not support GeoPoint at all. Others may\n  // Support additional types that Mongo doesn't, like Money, or something.\n\n  // TODO: don't spend an extra query on finding the schema if the type we are trying to add isn't a GeoPoint.\n  addFieldIfNotExists(className: string, fieldName: string, fieldType: string) {\n    return this._fetchOneSchemaFrom_SCHEMA(className)\n      .then(\n        schema => {\n          // If a field with this name already exists, it will be handled elsewhere.\n          if (schema.fields[fieldName] !== undefined) {\n            return;\n          }\n          // The schema exists. Check for existing GeoPoints.\n          if (fieldType.type === 'GeoPoint') {\n            // Make sure there are not other geopoint fields\n            if (\n              Object.keys(schema.fields).some(\n                existingField => schema.fields[existingField].type === 'GeoPoint'\n              )\n            ) {\n              throw new Parse.Error(\n                Parse.Error.INCORRECT_TYPE,\n                'MongoDB only supports one GeoPoint field in a class.'\n              );\n            }\n          }\n          return;\n        },\n        error => {\n          // If error is undefined, the schema doesn't exist, and we can create the schema with the field.\n          // If some other error, reject with it.\n          if (error === undefined) {\n            return;\n          }\n          throw error;\n        }\n      )\n      .then(() => {\n        const { type, targetClass, ...fieldOptions } = fieldType;\n        // We use $exists and $set to avoid overwriting the field type if it\n        // already exists. (it could have added inbetween the last query and the update)\n        if (fieldOptions && Object.keys(fieldOptions).length > 0) {\n          return this.upsertSchema(\n            className,\n            { [fieldName]: { $exists: false } },\n            {\n              $set: {\n                [fieldName]: parseFieldTypeToMongoFieldType({\n                  type,\n                  targetClass,\n                }),\n                [`_metadata.fields_options.${fieldName}`]: fieldOptions,\n              },\n            }\n          );\n        } else {\n          return this.upsertSchema(\n            className,\n            { [fieldName]: { $exists: false } },\n            {\n              $set: {\n                [fieldName]: parseFieldTypeToMongoFieldType({\n                  type,\n                  targetClass,\n                }),\n              },\n            }\n          );\n        }\n      });\n  }\n\n  async updateFieldOptions(className: string, fieldName: string, fieldType: any) {\n    const { ...fieldOptions } = fieldType;\n    delete fieldOptions.type;\n    delete fieldOptions.targetClass;\n\n    await this.upsertSchema(\n      className,\n      { [fieldName]: { $exists: true } },\n      {\n        $set: {\n          [`_metadata.fields_options.${fieldName}`]: fieldOptions,\n        },\n      }\n    );\n  }\n}\n\n// Exported for testing reasons and because we haven't moved all mongo schema format\n// related logic into the database adapter yet.\nMongoSchemaCollection._TESTmongoSchemaToParseSchema = mongoSchemaToParseSchema;\nMongoSchemaCollection.parseFieldTypeToMongoFieldType = parseFieldTypeToMongoFieldType;\n\nexport default MongoSchemaCollection;\n"],"mappings":"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","ignoreList":[]}