Adds schema caching capabilities (off by default)

Author: flovilmart

spec/ParseInstallation.spec.js

@@ -16,6 +16,11 @@ let defaultColumns = require('../src/Controllers/SchemaController').defaultColum
 const installationSchema = { fields: Object.assign({}, defaultColumns._Default, defaultColumns._Installation) };
 
 describe('Installations', () => {
+
+  beforeEach(() => {
+    config.database.schemaCache.reset();
+  });
+
   it_exclude_dbs(['postgres'])('creates an android installation with ids', (done) => {
     var installId = '12345678-abcd-abcd-abcd-123456789abc';
     var device = 'android';

spec/PointerPermissions.spec.js

@@ -4,6 +4,11 @@ var Schema = require('../src/Controllers/SchemaController');
 var Config = require('../src/Config');
 
 describe('Pointer Permissions', () => {
+
+  beforeEach(() => {
+    new Config(Parse.applicationId).database.schemaCache.reset();
+  });
+
   it_exclude_dbs(['postgres'])('should work with find', (done) => {
     let config = new Config(Parse.applicationId);
     let user = new Parse.User();

spec/Schema.spec.js

@@ -20,6 +20,10 @@ var hasAllPODobject = () => {
 };
 
 describe('SchemaController', () => {
+  beforeEach(() => {
+    config.database.schemaCache.reset();
+  });
+
   it('can validate one object', (done) => {
     config.database.loadSchema().then((schema) => {
       return schema.validateObject('TestObject', {a: 1, b: 'yo', c: false});

spec/schemas.spec.js

@@ -116,6 +116,11 @@ var masterKeyHeaders = {
 };
 
 describe('schemas', () => {
+
+  beforeEach(() => {
+     config.database.schemaCache.reset();
+  })
+
   it('requires the master key to get all schemas', (done) => {
     request.get({
       url: 'http://localhost:8378/1/schemas',

src/Config.js

@@ -3,6 +3,8 @@
 // mount is the URL for the root of the API; includes http, domain, etc.
 
 import AppCache from './cache';
+import SchemaCache from './Controllers/SchemaCache';
+import DatabaseController from './Controllers/DatabaseController';
 
 function removeTrailingSlash(str) {
   if (!str) {
@@ -31,7 +33,11 @@ export class Config {
     this.fileKey = cacheInfo.fileKey;
     this.facebookAppIds = cacheInfo.facebookAppIds;
     this.allowClientClassCreation = cacheInfo.allowClientClassCreation;
-    this.database = cacheInfo.databaseController;
+
+    // Create a new DatabaseController per request
+    if (cacheInfo.databaseController) {
+      this.database = new DatabaseController(cacheInfo.databaseController.adapter, new SchemaCache(applicationId, cacheInfo.schemaCacheTTL));
+    }
 
     this.serverURL = cacheInfo.serverURL;
     this.publicServerURL = removeTrailingSlash(cacheInfo.publicServerURL);

src/Controllers/DatabaseController.js

@@ -80,9 +80,9 @@ const validateQuery = query => {
   });
 }
 
-function DatabaseController(adapter) {
+function DatabaseController(adapter, schemaCache) {
   this.adapter = adapter;
-
+  this.schemaCache = schemaCache;
   // 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.
@@ -107,9 +107,9 @@ DatabaseController.prototype.validateClassName = function(className) {
 };
 
 // Returns a promise for a schemaController.
-DatabaseController.prototype.loadSchema = function() {
+DatabaseController.prototype.loadSchema = function(force = false) {
   if (!this.schemaPromise) {
-    this.schemaPromise = SchemaController.load(this.adapter);
+    this.schemaPromise = SchemaController.load(this.adapter, this.schemaCache, force);
     this.schemaPromise.then(() => delete this.schemaPromise);
   }
   return this.schemaPromise;
@@ -804,8 +804,8 @@ const untransformObjectACL = ({_rperm, _wperm, ...output}) => {
 }
 
 DatabaseController.prototype.deleteSchema = function(className) {
-  return this.loadSchema()
-  .then(schemaController => schemaController.getOneSchema(className))
+  return this.loadSchema(true)
+  .then(schemaController => schemaController.getOneSchema(className, true))
   .catch(error => {
     if (error === undefined) {
       return { fields: {} };

src/Controllers/SchemaCache.js

@@ -0,0 +1,50 @@
+import Parse from 'parse/node';
+import LRU from 'lru-cache';
+
+let MAIN_SCHEMA = "__MAIN_SCHEMA";
+
+export default class SchemaCache {
+  cache: Object;
+
+  constructor(appId: string, timeout: number = 0, maxSize: number = 10000) {
+    this.appId = appId;
+    this.timeout = timeout;
+    this.maxSize = maxSize;
+    this.cache = new LRU({
+      max: maxSize,
+      maxAge: timeout
+    });
+  }
+
+  get() {
+    if (this.timeout <= 0) {
+      return;
+    }
+    return this.cache.get(this.appId+MAIN_SCHEMA);
+  }
+
+  set(schema) {
+    if (this.timeout <= 0) {
+      return;
+    }
+    this.cache.set(this.appId+MAIN_SCHEMA, schema);
+  }
+
+  setOneSchema(className, schema) {
+    if (this.timeout <= 0) {
+      return;
+    }
+     this.cache.set(this.appId+className, schema);
+  }
+
+  getOneSchema(className) {
+    if (this.timeout <= 0) {
+      return;
+    }
+    return this.cache.get(this.appId+className);
+  }
+
+  reset() {
+    this.cache.reset();
+  }
+}

src/Controllers/SchemaController.js

@@ -273,19 +273,22 @@ class SchemaController {
   data;
   perms;
 
-  constructor(databaseAdapter) {
+  constructor(databaseAdapter, schemaCache) {
     this._dbAdapter = databaseAdapter;
-
+    this._cache = schemaCache;
     // this.data[className][fieldName] tells you the type of that field, in mongo format
     this.data = {};
     // this.perms[className][operation] tells you the acl-style permissions
     this.perms = {};
   }
 
-  reloadData() {
+  reloadData(clearCache = false) {
     this.data = {};
     this.perms = {};
-    return this.getAllClasses()
+    if (clearCache) {
+      this._cache.reset();
+    }
+    return this.getAllClasses(clearCache)
     .then(allSchemas => {
       allSchemas.forEach(schema => {
         this.data[schema.className] = injectDefaultSchema(schema).fields;
@@ -303,17 +306,39 @@ class SchemaController {
     });
   }
 
-  getAllClasses() {
+  getAllClasses(clearCache = false) {
+    if (clearCache) {
+      this._cache.reset();
+    }
+    let allClasses = this._cache.get();
+    if (allClasses && allClasses.length && !clearCache) {
+      return Promise.resolve(allClasses);
+    }
     return this._dbAdapter.getAllClasses()
-    .then(allSchemas => allSchemas.map(injectDefaultSchema));
+    .then(allSchemas => allSchemas.map(injectDefaultSchema))
+    .then(allSchemas => {
+      this._cache.set(allSchemas);
+      return allSchemas;
+    })
   }
 
-  getOneSchema(className, allowVolatileClasses = false) {
+  getOneSchema(className, allowVolatileClasses = false, clearCache) {
+    if (clearCache) {
+      this._cache.reset();
+    }
+    let cached = this._cache.getOneSchema(className);
+    if (cached && !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) => {
+      this._cache.setOneSchema(className, result);
+      return result;
+    })
   }
 
   // Create a new class that includes the three default fields.
@@ -331,6 +356,10 @@ class SchemaController {
 
     return this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({ fields, classLevelPermissions, className }))
     .then(convertAdapterSchemaToParseSchema)
+    .then((res) => {
+      this._cache.reset();
+      return res;
+    })
     .catch(error => {
       if (error && error.code === Parse.Error.DUPLICATE_VALUE) {
         throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);
@@ -376,7 +405,7 @@ class SchemaController {
       });
 
       return Promise.all(deletePromises) // Delete Everything
-      .then(() => this.reloadData()) // Reload our Schema, so we have all the new values
+      .then(() => this.reloadData(true)) // Reload our Schema, so we have all the new values
       .then(() => {
         let promises = insertedFields.map(fieldName => {
           const type = submittedFields[fieldName];
@@ -410,13 +439,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())
+    .then(() => this.reloadData(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();
+      return this.reloadData(true);
     })
     .then(() => {
       // Ensure that the schema now validates
@@ -486,7 +515,7 @@ class SchemaController {
     }
     validateCLP(perms, newSchema);
     return this._dbAdapter.setClassLevelPermissions(className, perms)
-    .then(() => this.reloadData());
+    .then(() => this.reloadData(true));
   }
 
   // Returns a promise that resolves successfully to the new schema
@@ -521,23 +550,26 @@ class SchemaController {
             `schema mismatch for ${className}.${fieldName}; expected ${expectedType.type || expectedType} but got ${type.type}`
           );
         }
+        return this;
       }
 
       return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => {
         // The update succeeded. Reload the schema
-        return this.reloadData();
+        return this.reloadData(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();
+        return this.reloadData(true);
       }).then(error => {
         // Ensure that the schema now validates
         if (!dbTypeMatchesObjectType(this.getExpectedType(className, fieldName), type)) {
           throw new Parse.Error(Parse.Error.INVALID_JSON, `Could not add field ${fieldName}`);
         }
+        // Remove the cached schema
+        this._cache.reset();
         return this;
       });
     });
@@ -562,7 +594,7 @@ class SchemaController {
       throw new Parse.Error(136, `field ${fieldName} cannot be changed`);
     }
 
-    return this.getOneSchema(className)
+    return this.getOneSchema(className, false, true)
     .catch(error => {
       if (error === undefined) {
         throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);
@@ -579,8 +611,9 @@ class SchemaController {
         return database.adapter.deleteFields(className, schema, [fieldName])
         .then(() => database.adapter.deleteClass(`_Join:${fieldName}:${className}`));
       }
-
       return database.adapter.deleteFields(className, schema, [fieldName]);
+    }).then(() => {
+      this._cache.reset();
     });
   }
 
@@ -711,9 +744,9 @@ class SchemaController {
 }
 
 // Returns a promise for a new Schema.
-const load = dbAdapter => {
-  let schema = new SchemaController(dbAdapter);
-  return schema.reloadData().then(() => schema);
+const load = (dbAdapter, schemaCache, clearCache) => {
+  let schema = new SchemaController(dbAdapter, schemaCache);
+  return schema.reloadData(clearCache).then(() => schema);
 }
 
 // Builds a new schema (in schema API response format) out of an

src/ParseServer.js

@@ -53,6 +53,7 @@ import { UsersRouter }          from './Routers/UsersRouter';
 import { PurgeRouter }          from './Routers/PurgeRouter';
 
 import DatabaseController       from './Controllers/DatabaseController';
+import SchemaCache              from './Controllers/SchemaCache';
 const SchemaController = require('./Controllers/SchemaController');
 import ParsePushAdapter         from 'parse-server-push-adapter';
 import MongoStorageAdapter      from './Adapters/Storage/Mongo/MongoStorageAdapter';
@@ -132,6 +133,7 @@ class ParseServer {
     expireInactiveSessions = true,
     verbose = false,
     revokeSessionOnPasswordReset = true,
+    schemaCacheTTL = -1, // -1 = no cache
     __indexBuildCompletionCallbackForTests = () => {},
   }) {
     // Initialize the node client SDK automatically
@@ -192,7 +194,8 @@ class ParseServer {
     const userController = new UserController(emailControllerAdapter, appId, { verifyUserEmails });
     const liveQueryController = new LiveQueryController(liveQuery);
     const cacheController = new CacheController(cacheControllerAdapter, appId);
-    const databaseController = new DatabaseController(databaseAdapter);
+    const schemaCache = new SchemaCache(appId, schemaCacheTTL);
+    const databaseController = new DatabaseController(databaseAdapter, schemaCache);
     const hooksController = new HooksController(appId, databaseController, webhookKey);
 
     // TODO: create indexes on first creation of a _User object. Otherwise it's impossible to
@@ -244,6 +247,8 @@ class ParseServer {
       expireInactiveSessions: expireInactiveSessions,
       revokeSessionOnPasswordReset,
       databaseController,
+      schemaCache,
+      schemaCacheTTL
     });
 
     // To maintain compatibility. TODO: Remove in some version that breaks backwards compatability