Remove collection prefix from DB Controller

Author: drew-gross

spec/DatabaseController.spec.js

@@ -6,11 +6,10 @@ let MongoStorageAdapter = require('../src/Adapters/Storage/Mongo/MongoStorageAda
 describe('DatabaseController', () => {
   it('can be constructed', done => {
     let adapter = new MongoStorageAdapter({
-      uri: 'mongodb://localhost:27017/test'
-    });
-    let databaseController = new DatabaseController(adapter, {
-      collectionPrefix: 'test_'
+      uri: 'mongodb://localhost:27017/test',
+      collectionPrefix: 'test_',
     });
+    let databaseController = new DatabaseController(adapter);
     databaseController.connect().then(done, error => {
       console.log('error', error.stack);
       fail();

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -50,37 +50,38 @@ export class MongoStorageAdapter {
 
   adaptiveCollection(name: string) {
     return this.connect()
-      .then(() => this.database.collection(name))
+      .then(() => this.database.collection(this._collectionPrefix + name))
       .then(rawCollection => new MongoCollection(rawCollection));
   }
 
-  schemaCollection(collectionPrefix: string) {
+  schemaCollection() {
     return this.connect()
-      .then(() => this.adaptiveCollection(collectionPrefix + MongoSchemaCollectionName))
+      .then(() => this.adaptiveCollection(this._collectionPrefix + MongoSchemaCollectionName))
       .then(collection => new MongoSchemaCollection(collection));
   }
 
   collectionExists(name: string) {
     return this.connect().then(() => {
-      return this.database.listCollections({ name: name }).toArray();
+      return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();
     }).then(collections => {
       return collections.length > 0;
     });
   }
 
   dropCollection(name: string) {
-    return this.collection(name).then(collection => collection.drop());
+    return this.collection(this._collectionPrefix + name).then(collection => collection.drop());
   }
+
   // Used for testing only right now.
-  collectionsContaining(match: string) {
+  allCollections() {
     return this.connect().then(() => {
       return this.database.collections();
     }).then(collections => {
       return collections.filter(collection => {
         if (collection.namespace.match(/\.system\./)) {
           return false;
         }
-        return (collection.collectionName.indexOf(match) == 0);
+        return (collection.collectionName.indexOf(this._collectionPrefix) == 0);
       });
     });
   }
@@ -106,12 +107,12 @@ export class MongoStorageAdapter {
 
   // Returns a Promise.
 
-  // This function currently accepts the collectionPrefix and adaptive collection as a paramater because it isn't
+  // This function currently accepts the adaptive collection as a paramater because it isn't
   // actually capable of determining the location of it's own _SCHEMA collection without having
   // the collectionPrefix. Also, Schemas.js, the caller of this function, only stores the collection
   // itself, and not the prefix. Eventually Parse Server won't care what a SchemaCollection is and
   // will just tell the DB adapter to do things and it will do them.
-  deleteFields(className: string, fieldNames, pointerFieldNames, collectionPrefix, adaptiveCollection) {
+  deleteFields(className: string, fieldNames, pointerFieldNames, adaptiveCollection) {
     const nonPointerFieldNames = _.difference(fieldNames, pointerFieldNames);
     const mongoFormatNames = nonPointerFieldNames.concat(pointerFieldNames.map(name => `_p_${name}`));
     const collectionUpdate = { '$unset' : {} };
@@ -125,9 +126,7 @@ export class MongoStorageAdapter {
     });
 
     return adaptiveCollection.updateMany({}, collectionUpdate)
-    .then(updateResult => {
-      return this.schemaCollection(collectionPrefix)
-    })
+    .then(updateResult => this.schemaCollection())
     .then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate));
   }
 }

src/Controllers/DatabaseController.js

@@ -10,13 +10,9 @@ var Schema = require('./../Schema');
 var transform = require('./../transform');
 const deepcopy = require('deepcopy');
 
-// options can contain:
-//   collectionPrefix: the string to put in front of every collection name.
-function DatabaseController(adapter, { collectionPrefix } = {}) {
+function DatabaseController(adapter) {
   this.adapter = adapter;
 
-  this.collectionPrefix = collectionPrefix;
-
   // We don't want a mutable this.schema, because then you could have
   // one request that uses different schemas for different parts of
   // it. Instead, use loadSchema to get a schema.
@@ -32,25 +28,21 @@ DatabaseController.prototype.connect = function() {
 };
 
 DatabaseController.prototype.adaptiveCollection = function(className) {
-  return this.adapter.adaptiveCollection(this.collectionPrefix + className);
+  return this.adapter.adaptiveCollection(className);
 };
 
 DatabaseController.prototype.schemaCollection = function() {
-  return this.adapter.schemaCollection(this.collectionPrefix);
+  return this.adapter.schemaCollection();
 };
 
 DatabaseController.prototype.collectionExists = function(className) {
-  return this.adapter.collectionExists(this.collectionPrefix + className);
+  return this.adapter.collectionExists(className);
 };
 
 DatabaseController.prototype.dropCollection = function(className) {
-  return this.adapter.dropCollection(this.collectionPrefix + className);
+  return this.adapter.dropCollection(className);
 };
 
-function returnsTrue() {
-  return true;
-}
-
 DatabaseController.prototype.validateClassName = function(className) {
   if (!Schema.classNameIsValid(className)) {
     const error = new Parse.Error(Parse.Error.INVALID_CLASS_NAME, 'invalid className: ' + className);
@@ -62,7 +54,7 @@ DatabaseController.prototype.validateClassName = function(className) {
 // Returns a promise for a schema object.
 // If we are provided a acceptor, then we run it on the schema.
 // If the schema isn't accepted, we reload it at most once.
-DatabaseController.prototype.loadSchema = function(acceptor = returnsTrue) {
+DatabaseController.prototype.loadSchema = function(acceptor = () => true) {
 
   if (!this.schemaPromise) {
     this.schemaPromise = this.schemaCollection().then(collection => {
@@ -388,10 +380,8 @@ DatabaseController.prototype.mongoFind = function(className, query, options = {}
 DatabaseController.prototype.deleteEverything = function() {
   this.schemaPromise = null;
 
-  return this.adapter.collectionsContaining(this.collectionPrefix).then(collections => {
-    let promises = collections.map(collection => {
-      return collection.drop();
-    });
+  return this.adapter.allCollections().then(collections => {
+    let promises = collections.map(collection => collection.drop());
     return Promise.all(promises);
   });
 };

src/DatabaseAdapter.js

@@ -21,14 +21,9 @@ import MongoStorageAdapter from './Adapters/Storage/Mongo/MongoStorageAdapter';
 const DefaultDatabaseURI = 'mongodb://localhost:27017/parse';
 
 let dbConnections = {};
-let databaseURI = DefaultDatabaseURI;
 let appDatabaseURIs = {};
 let appDatabaseOptions = {};
 
-function setDatabaseURI(uri) {
-  databaseURI = uri;
-}
-
 function setAppDatabaseURI(appId, uri) {
   appDatabaseURIs[appId] = uri;
 }
@@ -61,26 +56,21 @@ function getDatabaseConnection(appId: string, collectionPrefix: string) {
     return dbConnections[appId];
   }
 
-  var dbURI = (appDatabaseURIs[appId] ? appDatabaseURIs[appId] : databaseURI);
-
   let storageAdapter = new MongoStorageAdapter({
-    uri: dbURI,
+    uri: appDatabaseURIs[appId] ? appDatabaseURIs[appId] : DefaultDatabaseURI,
     collectionPrefix: collectionPrefix,
     mongoOptions: appDatabaseOptions[appId]
   });
 
-  dbConnections[appId] = new DatabaseController(storageAdapter, {
-    collectionPrefix: collectionPrefix
-  });
+  dbConnections[appId] = new DatabaseController(storageAdapter);
   return dbConnections[appId];
 }
 
 module.exports = {
   getDatabaseConnection: getDatabaseConnection,
-  setDatabaseURI: setDatabaseURI,
   setAppDatabaseOptions: setAppDatabaseOptions,
   setAppDatabaseURI: setAppDatabaseURI,
   clearDatabaseSettings: clearDatabaseSettings,
   destroyAllDataPermanently: destroyAllDataPermanently,
-  defaultDatabaseURI: databaseURI
+  defaultDatabaseURI: DefaultDatabaseURI
 };

src/Schema.js

@@ -526,7 +526,7 @@ class Schema {
       if (this.data[className][fieldName].type == 'Relation') {
         //For relations, drop the _Join table
         return database.adaptiveCollection(className).then(collection => {
-          return database.adapter.deleteFields(className, [fieldName], [], database.collectionPrefix, collection);
+          return database.adapter.deleteFields(className, [fieldName], [], collection);
         })
         .then(() => database.dropCollection(`_Join:${fieldName}:${className}`))
         .catch(error => {
@@ -542,7 +542,7 @@ class Schema {
       const fieldNames = [fieldName];
       const pointerFieldNames = this.data[className][fieldName].type === 'Pointer' ? [fieldName] : [];
       return database.adaptiveCollection(className)
-      .then(collection => database.adapter.deleteFields(className, fieldNames, pointerFieldNames, database.collectionPrefix, collection));
+      .then(collection => database.adapter.deleteFields(className, fieldNames, pointerFieldNames, collection));
     });
   }
 

src/testing-routes.js

@@ -1,8 +1,8 @@
 // testing-routes.js
-import cache from './cache';
+import cache            from './cache';
 import * as middlewares from './middlewares';
-import { ParseServer } from './index';
-import { Parse } from 'parse/node';
+import { ParseServer }  from './index';
+import { Parse }        from 'parse/node';
 
 var express = require('express'),
   cryptoUtils = require('./cryptoUtils');
@@ -31,7 +31,7 @@ function createApp(req, res) {
   res.status(200).send(keys);
 }
 
-// deletes all collections with the collectionPrefix of the app
+// deletes all collections that belong to the app
 function clearApp(req, res) {
   if (!req.auth.isMaster) {
     return res.status(401).send({ "error": "unauthorized" });