Use options object instead of boolean

Author: flovilmart

src/Controllers/DatabaseController.js

@@ -109,9 +109,9 @@ DatabaseController.prototype.validateClassName = function(className) {
 };
 
 // Returns a promise for a schemaController.
-DatabaseController.prototype.loadSchema = function(force = false) {
+DatabaseController.prototype.loadSchema = function(options = {clearCache: false}) {
   if (!this.schemaPromise) {
-    this.schemaPromise = SchemaController.load(this.adapter, this.schemaCache, force);
+    this.schemaPromise = SchemaController.load(this.adapter, this.schemaCache, options);
     this.schemaPromise.then(() => delete this.schemaPromise);
   }
   return this.schemaPromise;

src/Controllers/SchemaController.js

@@ -282,13 +282,13 @@ class SchemaController {
     this.perms = {};
   }
 
-  reloadData(clearCache = false) {
+  reloadData(options = {clearCache: false}) {
     this.data = {};
     this.perms = {};
-    if (clearCache) {
+    if (options.clearCache) {
       this._cache.clear();
     }
-    return this.getAllClasses(clearCache)
+    return this.getAllClasses(options)
     .then(allSchemas => {
       allSchemas.forEach(schema => {
         this.data[schema.className] = injectDefaultSchema(schema).fields;
@@ -306,12 +306,12 @@ class SchemaController {
     });
   }
 
-  getAllClasses(clearCache = false) {
-    if (clearCache) {
+  getAllClasses(options = {clearCache: false}) {
+    if (options.clearCache) {
       this._cache.clear();
     }
     return this._cache.getAllClasses().then((allClasses) => {
-      if (allClasses && allClasses.length && !clearCache) {
+      if (allClasses && allClasses.length && !options.clearCache) {
         return Promise.resolve(allClasses);
       }
       return this._dbAdapter.getAllClasses()
@@ -323,17 +323,17 @@ class SchemaController {
     });
   }
 
-  getOneSchema(className, allowVolatileClasses = false, clearCache) {
-    if (clearCache) {
+  getOneSchema(className, allowVolatileClasses = false, options = {clearCache: false}) {
+    if (options.clearCache) {
       this._cache.clear();
     }
+    if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {
+    	return Promise.resolve(this.data[className]);
+    }
     return this._cache.getOneSchema(className).then((cached) => {
-      if (cached && !clearCache) {
+      if (cached && !options.clearCache) {
         return Promise.resolve(cached);
       }
-      if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {
-        return Promise.resolve(this.data[className]);
-      }
       return this._dbAdapter.getClass(className)
       .then(injectDefaultSchema)
       .then((result) => {
@@ -407,7 +407,7 @@ class SchemaController {
       });
 
       return Promise.all(deletePromises) // Delete Everything
-      .then(() => this.reloadData(true)) // Reload our Schema, so we have all the new values
+      .then(() => this.reloadData({ clearCache: true })) // Reload our Schema, so we have all the new values
       .then(() => {
         let promises = insertedFields.map(fieldName => {
           const type = submittedFields[fieldName];
@@ -441,13 +441,13 @@ class SchemaController {
     // We don't have this class. Update the schema
     return this.addClassIfNotExists(className)
     // The schema update succeeded. Reload the schema
-    .then(() => this.reloadData(true))
+    .then(() => this.reloadData({ clearCache: true }))
     .catch(error => {
       // The schema update failed. This can be okay - it might
       // have failed because there's a race condition and a different
       // client is making the exact same schema update that we want.
       // So just reload the schema.
-      return this.reloadData(true);
+      return this.reloadData({ clearCache: true });
     })
     .then(() => {
       // Ensure that the schema now validates
@@ -517,7 +517,7 @@ class SchemaController {
     }
     validateCLP(perms, newSchema);
     return this._dbAdapter.setClassLevelPermissions(className, perms)
-    .then(() => this.reloadData(true));
+    .then(() => this.reloadData({ clearCache: true }));
   }
 
   // Returns a promise that resolves successfully to the new schema
@@ -557,14 +557,14 @@ class SchemaController {
 
       return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => {
         // The update succeeded. Reload the schema
-        return this.reloadData(true);
+        return this.reloadData({ clearCache: true });
       }, error => {
         //TODO: introspect the error and only reload if the error is one for which is makes sense to reload
 
         // The update failed. This can be okay - it might have been a race
         // condition where another client updated the schema in the same
         // way that we wanted to. So, just reload the schema
-        return this.reloadData(true);
+        return this.reloadData({ clearCache: true });
       }).then(error => {
         // Ensure that the schema now validates
         if (!dbTypeMatchesObjectType(this.getExpectedType(className, fieldName), type)) {
@@ -596,7 +596,7 @@ class SchemaController {
       throw new Parse.Error(136, `field ${fieldName} cannot be changed`);
     }
 
-    return this.getOneSchema(className, false, true)
+    return this.getOneSchema(className, false, {clearCache: true})
     .catch(error => {
       if (error === undefined) {
         throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);
@@ -746,9 +746,9 @@ class SchemaController {
 }
 
 // Returns a promise for a new Schema.
-const load = (dbAdapter, schemaCache, clearCache) => {
+const load = (dbAdapter, schemaCache, options) => {
   let schema = new SchemaController(dbAdapter, schemaCache);
-  return schema.reloadData(clearCache).then(() => schema);
+  return schema.reloadData(options).then(() => schema);
 }
 
 // Builds a new schema (in schema API response format) out of an

src/ParseServer.js

@@ -136,7 +136,7 @@ class ParseServer {
     expireInactiveSessions = true,
     verbose = false,
     revokeSessionOnPasswordReset = true,
-    schemaCacheTTL = 0, // 0 = no cache
+    schemaCacheTTL = 3600, // 0 = no cache
     __indexBuildCompletionCallbackForTests = () => {},
   }) {
     // Initialize the node client SDK automatically

src/Routers/SchemasRouter.js

@@ -15,14 +15,14 @@ function classNameMismatchResponse(bodyClass, pathClass) {
 }
 
 function getAllSchemas(req) {
-  return req.config.database.loadSchema(true)
+  return req.config.database.loadSchema({ clearCache: true})
   .then(schemaController => schemaController.getAllClasses(true))
   .then(schemas => ({ response: { results: schemas } }));
 }
 
 function getOneSchema(req) {
   const className = req.params.className;
-  return req.config.database.loadSchema(true)
+  return req.config.database.loadSchema({ clearCache: true})
   .then(schemaController => schemaController.getOneSchema(className, true))
   .then(schema => ({ response: schema }))
   .catch(error => {
@@ -46,7 +46,7 @@ function createSchema(req) {
     throw new Parse.Error(135, `POST ${req.path} needs a class name.`);
   }
 
-  return req.config.database.loadSchema(true)
+  return req.config.database.loadSchema({ clearCache: true})
     .then(schema => schema.addClassIfNotExists(className, req.body.fields, req.body.classLevelPermissions))
     .then(schema => ({ response: schema }));
 }
@@ -59,7 +59,7 @@ function modifySchema(req) {
   let submittedFields = req.body.fields || {};
   let className = req.params.className;
 
-  return req.config.database.loadSchema(true)
+  return req.config.database.loadSchema({ clearCache: true})
   .then(schema => schema.updateClass(className, submittedFields, req.body.classLevelPermissions, req.config.database))
   .then(result => ({response: result}));
 }