Clean up, added documentation. Moved resolveAdapter to the provider

Signed-off-by: Alexander Mays <[email protected]>

Author: Alexander Mays

Auth.js

@@ -1,6 +1,7 @@
 var deepcopy = require('deepcopy');
 var Parse = require('parse/node').Parse;
 var RestQuery = require('./RestQuery');
+var CacheProvider = require('./classes/CacheProvider');
 
 // An Auth object tells you who is requesting something and whether
 // the master key was used.
@@ -41,7 +42,7 @@ function nobody(config) {
 
 // Returns a promise that resolves to an Auth object
 var getAuthForSessionToken = function(config, sessionToken) {
-  var cache = require('./classes/CacheProvider').getAdapter();
+  var cache = CacheProvider.getAdapter();
 
   var cachedUser = cache.get(sessionToken);
   if (cachedUser) {

classes/BaseProvider.js

@@ -1,6 +1,13 @@
 var ServiceProviderInterface = require('../interfaces/ServiceProvider');
 var util = require('util');
 
+/**
+ * A base provider class that allows for an abstraction of adapter implementations
+ *
+ * @class
+ * @implements {ServiceProvider}
+ * @param {Object} adapter - An adapter
+ */
 function BaseProvider(adapter) {
     if (adapter) {
         this.adapter = adapter;
@@ -9,16 +16,47 @@ function BaseProvider(adapter) {
 
 util.inherits(BaseProvider, ServiceProviderInterface);
 
+/**
+ * Get the adapter
+ *
+ * @returns {Object} An adapter instance
+ */
 function getAdapter() {
     return this.adapter;
 }
 
+/**
+ * Set the adapter
+ * 
+ * @param {Object} adapter - An adapter
+ */
 function setAdapter(adapter) {
     this.adapter = adapter;
 }
 
+/**
+ * Resolves the adapter
+ * 
+ * @param {Object|String|Function} adapter - [1] An object implementing the adapter interface, or [2] a function that returns [1], or [3] A string of either the name of an included npm module or a path to a local module that returns [1] or [2].
+ * @param {Object} options - An object passed to the adapter on instantiation (if adapter is not already instantiated)
+ * @returns {Object} An object implementing the adapter interface
+ */
+function resolveAdapter(adapter, options) {
+    // Support passing in adapter paths
+    if (typeof adapter === 'string') {
+        adapter = require(adapter);
+    }
+
+    // Instantiate the adapter if the class got passed instead of an instance
+    if (typeof adapter === 'function') {
+        adapter = new adapter(options);
+    }
+
+    return adapter;
+}
+
 BaseProvider.prototype.getAdapter = getAdapter;
 BaseProvider.prototype.setAdapter = setAdapter;
-BaseProvider.prototype.BaseProvider = BaseProvider;
+BaseProvider.prototype.resolveAdapter = resolveAdapter;
 
-exports = module.exports = new BaseProvider();
+exports = module.exports = BaseProvider;

classes/CacheProvider.js

@@ -1,12 +1,38 @@
-var BaseProvider = require('./BaseProvider').BaseProvider;
 var util = require('util');
 
+var BaseProvider = require('./BaseProvider');
+var DefaultCacheAdapter = require('./MemoryCache');
+
+/**
+* Abstract class the provides a reference to an adapter instance (a caching implementation)
+*
+* @class
+* @extends {BaseProvider}
+* @param {Object} adapter - A cache adapter
+*/
 function CacheProvider(adapter) {
     CacheProvider.super_.call(this)
 };
 
+/**
+* Setup the cache provider given a configuration object
+*
+* @method
+* @param {Object} config - A configuration object
+* @param {Any} config.adapter - A string, object, instance, or function that resolves to an adapter implementation
+* @param {Object} config.options - An object passed to the adapter on instantiation (if adapter is not already instantiated)
+*/
+function setup (config) {
+  config = config || {};
+  config.adapter = config.adapter || DefaultCacheAdapter;
+
+  var adapter = this.resolveAdapter(config.adapter, config.options);
+  this.setAdapter(adapter);
+}
+
 util.inherits(CacheProvider, BaseProvider);
 
+CacheProvider.prototype.setup = setup;
 CacheProvider.prototype.CacheProvider = CacheProvider;
 
 exports = module.exports = new CacheProvider();

classes/MemoryCache.js

@@ -1,5 +1,13 @@
 'use strict';
 // Modified from https://github.com/ptarjan/node-cache/blob/master/index.js
+
+/**
+* Creates a new in-memory cache using Map for storage
+*
+* @class 
+* @param {Object} options - An object of default options
+* @param {String} [options.defaultTtl=600000] - The number of milliseconds to use as the default time-to-live of a cache entry
+*/
 function MemoryCache(options) {
     options = options || {};
 
@@ -10,6 +18,15 @@ function MemoryCache(options) {
     this.defaultTtl = options.defaultTtl || 10 * 60 * 1000;
 };
 
+/**
+ * Puts a key value mapping into the map that will automatically expire given a TTL.
+ * @method put
+ * @param {String} key - A unique key
+ * @param {Any} value - A value to be stored 
+ * @param {Number} ttl - The number of milliseconds until the key/value pair is removed from the cache
+ * @param {Function} timeoutCallback - A callback that is fired on expiration (post removal)
+ * @returns {Object} The MemoryCache instance
+ */
 function put (key, value, ttl, timeoutCallback) {
   if (this.debug) {
     console.log('caching: %s = %j (@%s)', key, value, ttl);
@@ -50,6 +67,12 @@ function put (key, value, ttl, timeoutCallback) {
   return value;
 };
 
+/**
+ * Deletes a key/value pair from the cache
+ * @method del
+ * @param {String} key - A unique key
+ * @returns {Boolean} True if a record was removed from the cache (a hit) or false if the record was not found (a miss)
+ */
 function del (key) {
   if (this.debug) {
     console.log('Deleting key ', key);
@@ -67,6 +90,10 @@ function del (key) {
   return false;
 };
 
+/**
+ * Resets the cache to it's original state
+ * @method clear
+ */
 function clear () {
   for (var entry of this.cache) {
     clearTimeout(entry[1].timeout);
@@ -76,13 +103,24 @@ function clear () {
   this.missCount = 0;
 };
 
+/**
+ * Disables a timer (timeout/expiration) for a specifiy key/value pair
+ * @method killTimer
+ * @param {String} key - A unique key
+ */
 function killTimer(key) {
     var obj = this.cache.get(key);
     if (obj && obj.timeout) {
         clearTimeout(obj.timeout);
     }
 };
 
+/**
+ * Retrieves a value given a key from the cache
+ * @method get
+ * @param {String} key - A unique key
+ * @returns {Any|undefined} Returns the value for the key in the cache or undefined if not found
+ */
 function get (key) {
   var data = this.cache.get(key);
   if (typeof data != "undefined") {
@@ -100,30 +138,61 @@ function get (key) {
   return undefined;
 };
 
+/**
+ * @method size
+ * @returns {Number} The number of key/value pairs in the cache
+ */
 function size () {
   return this.cache.size;
 };
 
+/**
+ * Toggles debug statements
+ * @method setDebug
+ * @param {Boolean} bool - The value to set debug
+ */
 function setDebug (bool) {
   this.debug = bool;
 };
 
+/**
+ * @method hits
+ * @returns {Number} The number of values successfully retrieved via get()
+ */
 function hits () {
   return this.hitCount;
 };
 
+/**
+ * @method misses
+ * @returns {Number} The number of unsuccessfully get attempts
+ */
 function misses () {
   return this.missCount;
 };
 
+/**
+ * @method keys
+ * @returns {Array} An array of all the keys in the map
+ */
 function keys () {
   return Array.from(this.cache.keys());
 };
 
+/**
+ * @method toArray
+ * @returns {Array} An array of all the values in the map
+ */
 function toArray() {
     return Array.from(this.cache.values());
 }
 
+/**
+ * @method map
+ * @param {Function} functor - A function that transforms a value for a given key/value pair
+ * @param {Object} context - The context for the functor call
+ * @returns {Map} A map containing key/value pairs where the original value was transformed by the provided functor
+ */
 function map(functor, context) {
     context = context || this;
     var result = new Map();
@@ -137,6 +206,12 @@ function map(functor, context) {
     return result;
 }
 
+/**
+ * @method filter
+ * @param {Function} predicate - A filter function
+ * @param {Object} context - The context for the predicate call
+ * @returns {Map} A map containing truthy results of a provided filter function
+ */
 function filter(predicate, context) {
     context = context || this;
     var result = new Map();

index.js

@@ -39,16 +39,13 @@ addParseCloud();
 // "restAPIKey": optional key from Parse dashboard
 // "javascriptKey": optional key from Parse dashboard
 
-var DefaultCacheAdapter = require('./classes/MemoryCache');
-
 function ParseServer(args) {
   if (!args.appId || !args.masterKey) {
     throw 'You must provide an appId and masterKey!';
   }
 
-  this.setupCache(args.cache);
-
-  var cache = this.cacheProvider.getAdapter();
+  // Setup providers
+  CacheProvider.setup(args.cache);
 
   if (args.databaseAdapter) {
     DatabaseAdapter.setAdapter(args.databaseAdapter);
@@ -66,7 +63,7 @@ function ParseServer(args) {
     } else if (typeof args.cloud === 'string') {
       require(args.cloud);
     } else {
-      throw "argument 'cloud' must either be a string or a function";
+      throw new Error("argument 'cloud' must either be a string or a function");
     }
 
   }
@@ -87,11 +84,14 @@ function ParseServer(args) {
     appInfo['facebookAppIds'].push(process.env.FACEBOOK_APP_ID);
   }
 
+  // Cache the application information indefinitely
+  var cache = CacheProvider.getAdapter();
   cache.put(args.appId, appInfo, Infinity);
 
   // Initialize the node client SDK automatically
   Parse.initialize(args.appId, args.javascriptKey || '', args.masterKey);
-  if(args.serverURL) {
+
+  if (args.serverURL) {
     Parse.serverURL = args.serverURL;
   }
 
@@ -175,33 +175,6 @@ function getClassName(parseClass) {
   return parseClass;
 }
 
-function resolveAdapter(adapter, options) {
-    // Support passing in adapter paths
-    if (typeof adapter === 'string') {
-        adapter = require(adapter);
-    }
-
-    // Instantiate the adapter if the class got passed instead of an instance
-    if (typeof adapter === 'function') {
-        adapter = new adapter(options);
-    }
-
-    return adapter;
-}
-
-// TODO: Add configurable TTLs for cache entries
-function setupCache(config) {
-  config = config || {};
-  config.adapter = config.adapter || DefaultCacheAdapter;
-
-  var adapter = this.resolveAdapter(config.adapter, config.options);
-  CacheProvider.setAdapter(adapter);
-  this.cacheProvider = CacheProvider;
-}
-
-ParseServer.prototype.setupCache = setupCache;
-ParseServer.prototype.resolveAdapter = resolveAdapter;
-
 module.exports = {
   ParseServer: ParseServer,
   S3Adapter: S3Adapter

interfaces/ServiceProvider.js

@@ -1,12 +1,36 @@
-function ServiceProviderInterface() {
+/**
+ * Interface for service providers
+ * 
+ * @interface
+ */
+function ServiceProvider() {
 };
 
-ServiceProviderInterface.prototype.getAdapter = function() {
+/**
+ * Get the adapter
+ *
+ * @returns {Object} An adapter instance
+ */
+ServiceProvider.prototype.getAdapter = function() {
     throw new Error('A service provider must implement getAdapter!');
 }
 
-ServiceProviderInterface.prototype.setAdapter = function() {
+/**
+ * Set the adapter
+ * 
+ * @param {Object} An adapter
+ */
+ServiceProvider.prototype.setAdapter = function() {
     throw new Error('A service provider must implement setAdapter!');
 }
 
-exports = module.exports = ServiceProviderInterface;
+/**
+ * Resolves the adapter from the first parameter
+ * 
+ * @param {Any}
+ */
+ServiceProvider.prototype.resolveAdapter = function() {
+    throw new Error('A service provider must implement resolveAdapter!');
+}
+
+exports = module.exports = ServiceProvider;