Adds liniting into the workflow (#3082)

* initial linting of src * fix indent to 2 spaces * Removes unnecessary rules * ignore spec folder for now * Spec linting * Fix spec indent * nits * nits * no no-empty rule
2016-11-24 15:47:41 -05:00
parent 6e2fba4ae4
commit 8c2c76dd26
149 changed files with 3478 additions and 3507 deletions
--- a/src/Controllers/AdaptableController.js
+++ b/src/Controllers/AdaptableController.js
@@ -50,15 +50,15 @@ export class AdaptableController {

    // Makes sure the prototype matches
    let mismatches = Object.getOwnPropertyNames(Type.prototype).reduce( (obj, key) => {
-       const adapterType = typeof adapter[key];
-       const expectedType = typeof Type.prototype[key];
-       if (adapterType !== expectedType) {
-         obj[key] = {
-           expected: expectedType,
-           actual: adapterType
-         }
-       }
-       return obj;
+      const adapterType = typeof adapter[key];
+      const expectedType = typeof Type.prototype[key];
+      if (adapterType !== expectedType) {
+        obj[key] = {
+          expected: expectedType,
+          actual: adapterType
+        }
+      }
+      return obj;
    }, {});

    if (Object.keys(mismatches).length > 0) {
--- a/src/Controllers/AnalyticsController.js
+++ b/src/Controllers/AnalyticsController.js
@@ -7,7 +7,7 @@ export class AnalyticsController extends AdaptableController {
      return this.adapter.appOpened(req.body, req);
    }).then((response) => {
      return { response: response || {} };
-    }).catch((err) => {
+    }).catch(() => {
      return { response: {} };
    });
  }
@@ -17,7 +17,7 @@ export class AnalyticsController extends AdaptableController {
      return this.adapter.trackEvent(req.params.eventName, req.body, req);
    }).then((response) => {
      return { response: response || {} };
-    }).catch((err) => {
+    }).catch(() => {
      return { response: {} };
    });
  }
--- a/src/Controllers/DatabaseController.js
+++ b/src/Controllers/DatabaseController.js
@@ -3,7 +3,6 @@

 import { Parse }              from 'parse/node';
 import _                      from 'lodash';
-import mongdb                 from 'mongodb';
 import intersect              from 'intersect';
 import deepcopy               from 'deepcopy';
 import logger                 from '../logger';
@@ -45,7 +44,7 @@ const transformObjectACL = ({ ACL, ...result }) => {

 const specialQuerykeys = ['$and', '$or', '_rperm', '_wperm', '_perishable_token', '_email_verify_token', '_email_verify_token_expires_at', '_account_lockout_expires_at', '_failed_login_count'];

-const isSpecialQueryKey = key => {
+const isSpecialQueryKey = key => {
  return specialQuerykeys.indexOf(key) >= 0;
 }

@@ -148,7 +147,7 @@ DatabaseController.prototype.validateObject = function(className, object, query,
      return Promise.resolve();
    }
    return this.canAddField(schema, className, object, aclGroup);
-  }).then(() => {
+  }).then(() => {
    return schema.validateObject(className, object, query);
  });
 };
@@ -193,7 +192,7 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => {
 //         write permissions.
 const specialKeysForUpdate = ['_hashed_password', '_perishable_token', '_email_verify_token', '_email_verify_token_expires_at', '_account_lockout_expires_at', '_failed_login_count', '_perishable_token_expires_at', '_password_changed_at'];

-const isSpecialUpdateKey = key => {
+const isSpecialUpdateKey = key => {
  return specialKeysForUpdate.indexOf(key) >= 0;
 }

@@ -208,7 +207,6 @@ DatabaseController.prototype.update = function(className, query, update, {

  var isMaster = acl === undefined;
  var aclGroup = acl || [];
-  var mongoUpdate;
  return this.loadSchema()
  .then(schemaController => {
    return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'update'))
@@ -280,7 +278,7 @@ function sanitizeDatabaseResult(originalObject, result) {
    let keyUpdate = originalObject[key];
    // determine if that was an op
    if (keyUpdate && typeof keyUpdate === 'object' && keyUpdate.__op
-      && ['Add', 'AddUnique', 'Remove', 'Increment'].indexOf(keyUpdate.__op) > -1) {
+      && ['Add', 'AddUnique', 'Remove', 'Increment'].indexOf(keyUpdate.__op) > -1) {
      // only valid ops that produce an actionable result
      response[key] = result[key];
    }
@@ -302,7 +300,7 @@ DatabaseController.prototype.handleRelationUpdates = function(className, objectI
      return;
    }
    if (op.__op == 'AddRelation') {
-      for (var object of op.objects) {
+      for (let object of op.objects) {
        pending.push(this.addRelation(key, className,
                                      objectId,
                                      object.objectId));
@@ -311,7 +309,7 @@ DatabaseController.prototype.handleRelationUpdates = function(className, objectI
    }

    if (op.__op == 'RemoveRelation') {
-      for (var object of op.objects) {
+      for (let object of op.objects) {
        pending.push(this.removeRelation(key, className,
                                         objectId,
                                         object.objectId));
@@ -326,10 +324,10 @@ DatabaseController.prototype.handleRelationUpdates = function(className, objectI
    }
  };

-  for (var key in update) {
+  for (let key in update) {
    process(update[key], key);
  }
-  for (var key of deleteMe) {
+  for (let key of deleteMe) {
    delete update[key];
  }
  return Promise.all(pending);
@@ -415,35 +413,35 @@ const flattenUpdateOperatorsForCreate = object => {
  for (let key in object) {
    if (object[key] && object[key].__op) {
      switch (object[key].__op) {
-        case 'Increment':
-          if (typeof object[key].amount !== 'number') {
-            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
-          }
-          object[key] = object[key].amount;
-          break;
-        case 'Add':
-          if (!(object[key].objects instanceof Array)) {
-            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
-          }
-          object[key] = object[key].objects;
-          break;
-        case 'AddUnique':
-          if (!(object[key].objects instanceof Array)) {
-            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
-          }
-          object[key] = object[key].objects;
-          break;
-        case 'Remove':
-          if (!(object[key].objects instanceof Array)) {
-            throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
-          }
-          object[key] = []
-          break;
-        case 'Delete':
-          delete object[key];
-          break;
-        default:
-          throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, `The ${object[key].__op} operator is not supported yet.`);
+      case 'Increment':
+        if (typeof object[key].amount !== 'number') {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
+        }
+        object[key] = object[key].amount;
+        break;
+      case 'Add':
+        if (!(object[key].objects instanceof Array)) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
+        }
+        object[key] = object[key].objects;
+        break;
+      case 'AddUnique':
+        if (!(object[key].objects instanceof Array)) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
+        }
+        object[key] = object[key].objects;
+        break;
+      case 'Remove':
+        if (!(object[key].objects instanceof Array)) {
+          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');
+        }
+        object[key] = []
+        break;
+      case 'Delete':
+        delete object[key];
+        break;
+      default:
+        throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, `The ${object[key].__op} operator is not supported yet.`);
      }
    }
  }
@@ -451,7 +449,7 @@ const flattenUpdateOperatorsForCreate = object => {

 const transformAuthData = (className, object, schema) => {
  if (object.authData && className === '_User') {
-    Object.keys(object.authData).forEach(provider => {
+    Object.keys(object.authData).forEach(provider => {
      const providerData = object.authData[provider];
      const fieldName = `_auth_data_${provider}`;
      if (providerData == null) {
@@ -504,7 +502,7 @@ DatabaseController.prototype.canAddField = function(schema, className, object, a
  }
  let fields = Object.keys(object);
  let schemaFields = Object.keys(classSchema);
-  let newKeys = fields.filter((field) => {
+  let newKeys = fields.filter((field) => {
    return schemaFields.indexOf(field) < 0;
  })
  if (newKeys.length > 0) {
@@ -523,20 +521,6 @@ DatabaseController.prototype.deleteEverything = function() {
  ]);
 };

-// Finds the keys in a query. Returns a Set. REST format only
-function keysForQuery(query) {
-  var sublist = query['$and'] || query['$or'];
-  if (sublist) {
-    let answer = sublist.reduce((memo, subquery) => {
-      return memo.concat(keysForQuery(subquery));
-    }, []);
-
-    return new Set(answer);
-  }
-
-  return new Set(Object.keys(query));
-}
-
 // Returns a promise for a list of related ids given an owning id.
 // className here is the owning className.
 DatabaseController.prototype.relatedIds = function(className, key, owningId) {
@@ -561,10 +545,10 @@ DatabaseController.prototype.reduceInRelation = function(className, query, schem
  if (query['$or']) {
    let ors = query['$or'];
    return Promise.all(ors.map((aQuery, index) => {
-      return this.reduceInRelation(className, aQuery, schema).then((aQuery) => {
+      return this.reduceInRelation(className, aQuery, schema).then((aQuery) => {
        query['$or'][index] = aQuery;
      });
-    })).then(() => {
+    })).then(() => {
      return Promise.resolve(query);
    });
  }
@@ -575,7 +559,6 @@ DatabaseController.prototype.reduceInRelation = function(className, query, schem
      if (!t || t.type !== 'Relation') {
        return Promise.resolve(query);
      }
-      let relatedClassName = t.targetClass;
      // Build the list of queries
      let queries = Object.keys(query[key]).map((constraintKey) => {
        let relatedIds;
@@ -625,7 +608,7 @@ DatabaseController.prototype.reduceInRelation = function(className, query, schem
    return Promise.resolve();
  })

-  return Promise.all(promises).then(() => {
+  return Promise.all(promises).then(() => {
    return Promise.resolve(query);
  })
 };
@@ -839,7 +822,7 @@ DatabaseController.prototype.deleteSchema = function(className) {
  })
  .then(schema => {
    return this.collectionExists(className)
-    .then(exist => this.adapter.count(className, { fields: {} }))
+    .then(() => this.adapter.count(className, { fields: {} }))
    .then(count => {
      if (count > 0) {
        throw new Parse.Error(255, `Class ${className} is not empty, contains ${count} objects, cannot drop schema.`);
@@ -866,10 +849,10 @@ DatabaseController.prototype.addPointerPermissions = function(schema, className,
  let perms = schema.perms[className];
  let field = ['get', 'find'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';
  let userACL = aclGroup.filter((acl) => {
-     return acl.indexOf('role:') != 0 && acl != '*';
+    return acl.indexOf('role:') != 0 && acl != '*';
  });
  // the ACL should have exactly 1 user
-  if (perms && perms[field] && perms[field].length > 0) {
+  if (perms && perms[field] && perms[field].length > 0) {
    // No user set return undefined
    // If the length is > 1, that means we didn't dedup users correctly
    if (userACL.length != 1) {
@@ -877,20 +860,19 @@ DatabaseController.prototype.addPointerPermissions = function(schema, className,
    }
    let userId = userACL[0];
    let userPointer =  {
-          "__type": "Pointer",
-          "className": "_User",
-          "objectId": userId
-        };
+      "__type": "Pointer",
+      "className": "_User",
+      "objectId": userId
+    };

-    let constraints = {};
    let permFields = perms[field];
-    let ors = permFields.map((key) => {
+    let ors = permFields.map((key) => {
      let q = {
        [key]: userPointer
      };
      return {'$and': [q, query]};
    });
-    if (ors.length > 1) {
+    if (ors.length > 1) {
      return {'$or': ors};
    }
    return ors[0];
--- a/src/Controllers/FilesController.js
+++ b/src/Controllers/FilesController.js
@@ -1,5 +1,4 @@
 // FilesController.js
-import { Parse } from 'parse/node';
 import { randomHexString } from '../cryptoUtils';
 import AdaptableController from './AdaptableController';
 import { FilesAdapter } from '../Adapters/Files/FilesAdapter';
@@ -85,7 +84,7 @@ export class FilesController extends AdaptableController {

  getFileStream(config, filename) {
    return this.adapter.getFileStream(filename);
-   }
+  }
 }

 export default FilesController;
--- a/src/Controllers/HooksController.js
+++ b/src/Controllers/HooksController.js
@@ -51,8 +51,7 @@ export class HooksController {
    return this._removeHooks({ className: className, triggerName: triggerName });
  }

-  _getHooks(query = {}, limit) {
-    let options = limit ? { limit: limit } : undefined;
+  _getHooks(query = {}) {
    return this.database.find(DefaultHooksCollectionName, query).then((results) => {
      return results.map((result) => {
        delete result.objectId;
@@ -113,7 +112,7 @@ export class HooksController {
    }

    return this.addHook(hook);
-  };
+  }

  createHook(aHook) {
    if (aHook.functionName) {
@@ -134,7 +133,7 @@ export class HooksController {
    }

    throw new Parse.Error(143, "invalid hook declaration");
-  };
+  }

  updateHook(aHook) {
    if (aHook.functionName) {
@@ -153,7 +152,7 @@ export class HooksController {
      });
    }
    throw new Parse.Error(143, "invalid hook declaration");
-  };
+  }
 }

 function wrapToHTTPRequest(hook, key) {
@@ -170,7 +169,7 @@ function wrapToHTTPRequest(hook, key) {
      jsonBody.original = req.original.toJSON();
      jsonBody.original.className = req.original.className;
    }
-    let jsonRequest = {
+    let jsonRequest: any = {
      headers: {
        'Content-Type': 'application/json'
      },
--- a/src/Controllers/LiveQueryController.js
+++ b/src/Controllers/LiveQueryController.js
@@ -5,7 +5,6 @@ export class LiveQueryController {
  liveQueryPublisher: any;

  constructor(config: any) {
-    let classNames;
    // If config is empty, we just assume no classs needs to be registered as LiveQuery
    if (!config || !config.classNames) {
      this.classNames = new Set();
--- a/src/Controllers/LoggerController.js
+++ b/src/Controllers/LoggerController.js
@@ -1,5 +1,4 @@
 import { Parse } from 'parse/node';
-import PromiseRouter from '../PromiseRouter';
 import AdaptableController from './AdaptableController';
 import { LoggerAdapter } from '../Adapters/Logger/LoggerAdapter';
 import url from 'url';
--- a/src/Controllers/PushController.js
+++ b/src/Controllers/PushController.js
@@ -1,5 +1,4 @@
 import { Parse }              from 'parse/node';
-import PromiseRouter          from '../PromiseRouter';
 import rest                   from '../rest';
 import AdaptableController    from './AdaptableController';
 import { PushAdapter }        from '../Adapters/Push/PushAdapter';
@@ -9,7 +8,6 @@ import RestWrite              from '../RestWrite';
 import { master }             from '../Auth';
 import { pushStatusHandler }  from '../StatusHandler';

-const FEATURE_NAME = 'push';
 const UNSUPPORTED_BADGE_KEY = "unsupported";

 export class PushController extends AdaptableController {
@@ -24,7 +22,7 @@ export class PushController extends AdaptableController {
    var deviceTypes = [];
    if (typeof deviceTypeField === 'string') {
      deviceTypes.push(deviceTypeField);
-    } else if (typeof deviceTypeField['$in'] === 'array') {
+    } else if (Array.isArray(deviceTypeField['$in'])) {
      deviceTypes.concat(deviceTypeField['$in']);
    }
    for (var i = 0; i < deviceTypes.length; i++) {
@@ -98,13 +96,13 @@ export class PushController extends AdaptableController {
    }).then((results) => {
      return pushStatus.complete(results);
    }).catch((err) => {
-      return pushStatus.fail(err).then(() => {
+      return pushStatus.fail(err).then(() => {
        throw err;
      });
    });
  }

-  sendToAdapter(body, installations, pushStatus, config) {
+  sendToAdapter(body, installations, pushStatus) {
    if (body.data && body.data.badge && typeof body.data.badge == 'string' && body.data.badge.toLowerCase() == "increment") {
      // Collect the badges to reduce the # of calls
      let badgeInstallationsMap = installations.reduce((map, installation) => {
--- a/src/Controllers/SchemaCache.js
+++ b/src/Controllers/SchemaCache.js
@@ -21,7 +21,7 @@ export default class SchemaCache {
  }

  put(key, value) {
-    return this.cache.get(this.prefix+ALL_KEYS).then((allKeys) => {
+    return this.cache.get(this.prefix+ALL_KEYS).then((allKeys) => {
      allKeys = allKeys || {};
      allKeys[key] = true;
      return Promise.all([this.cache.put(this.prefix+ALL_KEYS, allKeys, this.ttl), this.cache.put(key, value, this.ttl)]);
@@ -72,8 +72,7 @@ export default class SchemaCache {

  clear() {
    // That clears all caches...
-    let promise = Promise.resolve();
-    return this.cache.get(this.prefix+ALL_KEYS).then((allKeys) => {
+    return this.cache.get(this.prefix+ALL_KEYS).then((allKeys) => {
      if (!allKeys) {
        return;
      }
--- a/src/Controllers/SchemaController.js
+++ b/src/Controllers/SchemaController.js
@@ -15,7 +15,6 @@
 // TODO: hide all schema logic inside the database adapter.

 const Parse = require('parse/node').Parse;
-import _ from 'lodash';

 const defaultColumns = Object.freeze({
  // Contain the default columns for every parse object type (except _Join collection)
@@ -152,7 +151,7 @@ function validateCLP(perms, fields) {
      } else {
        perms[operation].forEach((key) => {
          if (!fields[key] || fields[key].type != 'Pointer' || fields[key].targetClass != '_User') {
-             throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid column for class level pointer permissions ${operation}`);
+            throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid column for class level pointer permissions ${operation}`);
          }
        });
      }
@@ -222,19 +221,19 @@ const fieldTypeIsInvalid = ({ type, targetClass }) => {
    if (!targetClass) {
      return new Parse.Error(135, `type ${type} needs a class name`);
    } else if (typeof targetClass !== 'string') {
-       return invalidJsonError;
+      return invalidJsonError;
    } else if (!classNameIsValid(targetClass)) {
      return new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(targetClass));
-     } else {
+    } else {
      return undefined;
-     }
-   }
-   if (typeof type !== 'string') {
+    }
+  }
+  if (typeof type !== 'string') {
    return invalidJsonError;
-   }
+  }
  if (validNonRelationOrPointerTypes.indexOf(type) < 0) {
    return new Parse.Error(Parse.Error.INCORRECT_TYPE, `invalid field type: ${type}`);
-   }
+  }
  return undefined;
 }

@@ -280,14 +279,14 @@ const injectDefaultSchema = ({className, fields, classLevelPermissions}) => ({
 const _HooksSchema =  {className: "_Hooks", fields: defaultColumns._Hooks};
 const _GlobalConfigSchema = { className: "_GlobalConfig", fields: defaultColumns._GlobalConfig }
 const _PushStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
-    className: "_PushStatus",
-    fields: {},
-    classLevelPermissions: {}
+  className: "_PushStatus",
+  fields: {},
+  classLevelPermissions: {}
 }));
 const _JobStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({
-    className: "_JobStatus",
-    fields: {},
-    classLevelPermissions: {}
+  className: "_JobStatus",
+  fields: {},
+  classLevelPermissions: {}
 }));
 const VolatileClassesSchemas = [_HooksSchema, _JobStatusSchema, _PushStatusSchema, _GlobalConfigSchema];

@@ -325,7 +324,7 @@ export default class SchemaController {
  reloadData(options = {clearCache: false}) {
    let promise = Promise.resolve();
    if (options.clearCache) {
-      promise = promise.then(() => {
+      promise = promise.then(() => {
        return this._cache.clear();
      });
    }
@@ -334,7 +333,7 @@ export default class SchemaController {
    }
    this.data = {};
    this.perms = {};
-    this.reloadDataPromise = promise.then(() => {
+    this.reloadDataPromise = promise.then(() => {
      return this.getAllClasses(options);
    })
    .then(allSchemas => {
@@ -352,7 +351,7 @@ export default class SchemaController {
        });
      });
      delete this.reloadDataPromise;
-    }, (err) => {
+    }, (err) => {
      delete this.reloadDataPromise;
      throw err;
    });
@@ -364,16 +363,16 @@ export default class SchemaController {
    if (options.clearCache) {
      promise = this._cache.clear();
    }
-    return promise.then(() => {
-       return this._cache.getAllClasses()
-    }).then((allClasses) => {
+    return promise.then(() => {
+      return this._cache.getAllClasses()
+    }).then((allClasses) => {
      if (allClasses && allClasses.length && !options.clearCache) {
        return Promise.resolve(allClasses);
      }
      return this._dbAdapter.getAllClasses()
        .then(allSchemas => allSchemas.map(injectDefaultSchema))
        .then(allSchemas => {
-          return this._cache.setAllClasses(allSchemas).then(() => {
+          return this._cache.setAllClasses(allSchemas).then(() => {
            return allSchemas;
          });
        })
@@ -385,18 +384,18 @@ export default class SchemaController {
    if (options.clearCache) {
      promise = this._cache.clear();
    }
-    return promise.then(() => {
+    return promise.then(() => {
      if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {
        return Promise.resolve(this.data[className]);
      }
-      return this._cache.getOneSchema(className).then((cached) => {
+      return this._cache.getOneSchema(className).then((cached) => {
        if (cached && !options.clearCache) {
          return Promise.resolve(cached);
        }
        return this._dbAdapter.getClass(className)
        .then(injectDefaultSchema)
-        .then((result) => {
-          return this._cache.setOneSchema(className, result).then(() => {
+        .then((result) => {
+          return this._cache.setOneSchema(className, result).then(() => {
            return result;
          })
        });
@@ -419,9 +418,9 @@ export default class SchemaController {

    return this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({ fields, classLevelPermissions, className }))
    .then(convertAdapterSchemaToParseSchema)
-    .then((res) => {
-      return this._cache.clear().then(() => {
-         return Promise.resolve(res);
+    .then((res) => {
+      return this._cache.clear().then(() => {
+        return Promise.resolve(res);
      });
    })
    .catch(error => {
@@ -504,7 +503,7 @@ export default class SchemaController {
    return this.addClassIfNotExists(className)
    // The schema update succeeded. Reload the schema
    .then(() => this.reloadData({ clearCache: true }))
-    .catch(error => {
+    .catch(() => {
      // 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.
@@ -519,7 +518,7 @@ export default class SchemaController {
        throw new Parse.Error(Parse.Error.INVALID_JSON, `Failed to add ${className}`);
      }
    })
-    .catch(error => {
+    .catch(() => {
      // The schema still doesn't validate. Give up
      throw new Parse.Error(Parse.Error.INVALID_JSON, 'schema class name does not revalidate');
    });
@@ -586,7 +585,7 @@ export default class SchemaController {
  // object if the provided className-fieldName-type tuple is valid.
  // The className must already be validated.
  // If 'freeze' is true, refuse to update the schema for this field.
-  enforceFieldExists(className, fieldName, type, freeze) {
+  enforceFieldExists(className, fieldName, type) {
    if (fieldName.indexOf(".") > 0) {
      // subdocument key (x.y) => ok if x is of type 'object'
      fieldName = fieldName.split(".")[ 0 ];
@@ -620,14 +619,14 @@ export default class SchemaController {
      return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => {
        // The update succeeded. Reload the schema
        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({ clearCache: true });
-      }).then(error => {
+      }).then(() => {
        // 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}`);
@@ -676,7 +675,7 @@ export default class SchemaController {
        .then(() => database.adapter.deleteClass(`_Join:${fieldName}:${className}`));
      }
      return database.adapter.deleteFields(className, schema, [fieldName]);
-    }).then(() => {
+    }).then(() => {
      this._cache.clear();
    });
  }
@@ -772,7 +771,6 @@ export default class SchemaController {
      return true;
    }
    let classPerms = this.perms[className];
-    let perms = classPerms[operation];
    // No matching CLP, let's check the Pointer permissions
    // And handle those later
    let permissionField = ['get', 'find'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';
@@ -785,11 +783,11 @@ export default class SchemaController {

    // Process the readUserFields later
    if (Array.isArray(classPerms[permissionField]) && classPerms[permissionField].length > 0) {
-        return Promise.resolve();
+      return Promise.resolve();
    }
    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,
        `Permission denied for action ${operation} on class ${className}.`);
-  };
+  }

  // Returns the expected type for a className+key combination
  // or undefined if the schema is not set
@@ -799,7 +797,7 @@ export default class SchemaController {
      return expectedType === 'map' ? 'Object' : expectedType;
    }
    return undefined;
-  };
+  }

  // Checks if a given class is in the schema.
  hasClass(className) {
@@ -859,23 +857,23 @@ function thenValidateRequiredColumns(schemaPromise, className, object, query) {
 function getType(obj) {
  let type = typeof obj;
  switch(type) {
-    case 'boolean':
-      return 'Boolean';
-    case 'string':
-      return 'String';
-    case 'number':
-      return 'Number';
-    case 'map':
-    case 'object':
-      if (!obj) {
-        return undefined;
-      }
-      return getObjectType(obj);
-    case 'function':
-    case 'symbol':
-    case 'undefined':
-    default:
-      throw 'bad obj: ' + obj;
+  case 'boolean':
+    return 'Boolean';
+  case 'string':
+    return 'String';
+  case 'number':
+    return 'Number';
+  case 'map':
+  case 'object':
+    if (!obj) {
+      return undefined;
+    }
+    return getObjectType(obj);
+  case 'function':
+  case 'symbol':
+  case 'undefined':
+  default:
+    throw 'bad obj: ' + obj;
  }
 }

@@ -888,63 +886,68 @@ function getObjectType(obj) {
  }
  if (obj.__type){
    switch(obj.__type) {
-      case 'Pointer' :
-        if(obj.className) {
-          return {
-            type: 'Pointer',
-            targetClass: obj.className
-          }
+    case 'Pointer' :
+      if(obj.className) {
+        return {
+          type: 'Pointer',
+          targetClass: obj.className
        }
-      case 'Relation' :
-        if(obj.className) {
-          return {
-            type: 'Relation',
-            targetClass: obj.className
-          }
+      }
+      break;
+    case 'Relation' :
+      if(obj.className) {
+        return {
+          type: 'Relation',
+          targetClass: obj.className
        }
-      case 'File' :
-        if(obj.name) {
-          return 'File';
-        }
-      case 'Date' :
-        if(obj.iso) {
-          return 'Date';
-        }
-      case 'GeoPoint' :
-        if(obj.latitude != null && obj.longitude != null) {
-          return 'GeoPoint';
-        }
-      case 'Bytes' :
-        if(obj.base64) {
-          return;
-        }
-      default:
-        throw new Parse.Error(Parse.Error.INCORRECT_TYPE, "This is not a valid "+obj.__type);
+      }
+      break;
+    case 'File' :
+      if(obj.name) {
+        return 'File';
+      }
+      break;
+    case 'Date' :
+      if(obj.iso) {
+        return 'Date';
+      }
+      break;
+    case 'GeoPoint' :
+      if(obj.latitude != null && obj.longitude != null) {
+        return 'GeoPoint';
+      }
+      break;
+    case 'Bytes' :
+      if(obj.base64) {
+        return;
+      }
+      break;
    }
+    throw new Parse.Error(Parse.Error.INCORRECT_TYPE, "This is not a valid "+obj.__type);
  }
  if (obj['$ne']) {
    return getObjectType(obj['$ne']);
  }
  if (obj.__op) {
    switch(obj.__op) {
-      case 'Increment':
-        return 'Number';
-      case 'Delete':
-        return null;
-      case 'Add':
-      case 'AddUnique':
-      case 'Remove':
-        return 'Array';
-      case 'AddRelation':
-      case 'RemoveRelation':
-        return {
-          type: 'Relation',
-          targetClass: obj.objects[0].className
-        }
-      case 'Batch':
-        return getObjectType(obj.ops[0]);
-      default:
-        throw 'unexpected op: ' + obj.__op;
+    case 'Increment':
+      return 'Number';
+    case 'Delete':
+      return null;
+    case 'Add':
+    case 'AddUnique':
+    case 'Remove':
+      return 'Array';
+    case 'AddRelation':
+    case 'RemoveRelation':
+      return {
+        type: 'Relation',
+        targetClass: obj.objects[0].className
+      }
+    case 'Batch':
+      return getObjectType(obj.ops[0]);
+    default:
+      throw 'unexpected op: ' + obj.__op;
    }
  }
  return 'Object';
--- a/src/Controllers/UserController.js
+++ b/src/Controllers/UserController.js
@@ -3,10 +3,9 @@ import { inflate }         from '../triggers';
 import AdaptableController from './AdaptableController';
 import MailAdapter         from '../Adapters/Email/MailAdapter';
 import rest                from '../rest';
+import Parse               from 'parse/node';

-var RestWrite = require('../RestWrite');
 var RestQuery = require('../RestQuery');
-var hash = require('../password').hash;
 var Auth = require('../Auth');

 export class UserController extends AdaptableController {
@@ -118,7 +117,7 @@ export class UserController extends AdaptableController {
    }
    const token = encodeURIComponent(user._email_verify_token);
    // We may need to fetch the user in case of update email
-    this.getUserIfNeeded(user).then((user) => {
+    this.getUserIfNeeded(user).then((user) => {
      const username = encodeURIComponent(user.username);
      let link = `${this.config.verifyEmailURL}?token=${token}&username=${username}`;
      let options = {
@@ -148,7 +147,6 @@ export class UserController extends AdaptableController {
    if (!this.adapter) {
      throw "Trying to send a reset password but no adapter is set";
      //  TODO: No adapter?
-      return;
    }

    return this.setPasswordResetToken(email)
@@ -173,7 +171,7 @@ export class UserController extends AdaptableController {
    });
  }

-  updatePassword(username, token, password, config) {
+  updatePassword(username, token, password) {
    return this.checkResetTokenValidity(username, token)
      .then(user => updateUserPassword(user.objectId, password, this.config))
      // clear reset password token
@@ -191,9 +189,9 @@ export class UserController extends AdaptableController {

  defaultVerificationEmail({link, user, appName, }) {
    let text = "Hi,\n\n" +
-	      "You are being asked to confirm the e-mail address " + user.get("email") + " with " + appName + "\n\n" +
-	      "" +
-	      "Click here to confirm it:\n" + link;
+        "You are being asked to confirm the e-mail address " + user.get("email") + " with " + appName + "\n\n" +
+        "" +
+        "Click here to confirm it:\n" + link;
    let to = user.get("email");
    let subject = 'Please verify your e-mail for ' + appName;
    return { text, to, subject };
@@ -215,6 +213,6 @@ function updateUserPassword(userId, password, config) {
  return rest.update(config, Auth.master(config), '_User', userId, {
    password: password
  });
- }
+}

 export default UserController;