diff --git a/spec/ParseHooks.spec.js b/spec/ParseHooks.spec.js
index 2a0cec5a..d3c04f69 100644
--- a/spec/ParseHooks.spec.js
+++ b/spec/ParseHooks.spec.js
@@ -76,7 +76,7 @@ describe('Hooks', () => {
     })
   });
 
-   it("should CRUD a trigger registration", (done) => {
+  it("should CRUD a trigger registration", (done) => {
      // Create
      Parse.Hooks.createTrigger("MyClass","beforeDelete", "http://someurl").then((res) => {
        expect(res.className).toBe("MyClass");
diff --git a/src/Adapters/Storage/Mongo/MongoTransform.js b/src/Adapters/Storage/Mongo/MongoTransform.js
index 783ff98e..c537a1c4 100644
--- a/src/Adapters/Storage/Mongo/MongoTransform.js
+++ b/src/Adapters/Storage/Mongo/MongoTransform.js
@@ -130,59 +130,52 @@ function transformKeyValue(schema, className, restKey, restValue, {
   return {key: key, value: value};
 }
 
-function transformQueryKeyValue(schema, className, restKey, restValue, { validate } = {}) {
+const valueAsDate = value => {
+  if (typeof value === 'string') {
+    return new Date(value);
+  } else if (value instanceof Date) {
+    return value;
+  }
+  return false;
+}
+
+function transformQueryKeyValue(schema, className, key, value, { validate } = {}) {
   // Check if the schema is known since it's a built-in field.
-  var key = restKey;
-  var timeField = false;
   switch(key) {
-  case 'objectId':
-  case '_id':
-    key = '_id';
-    break;
   case 'createdAt':
-  case '_created_at':
+    if (valueAsDate(value)) {
+      return {key: '_created_at', value: valueAsDate(value)}
+    }
     key = '_created_at';
-    timeField = true;
     break;
   case 'updatedAt':
-  case '_updated_at':
+    if (valueAsDate(value)) {
+      return {key: '_updated_at', value: valueAsDate(value)}
+    }
     key = '_updated_at';
-    timeField = true;
-    break;
-  case '_email_verify_token':
-    key = "_email_verify_token";
-    break;
-  case '_perishable_token':
-    key = "_perishable_token";
-    break;
-  case 'sessionToken':
-  case '_session_token':
-    key = '_session_token';
     break;
   case 'expiresAt':
-  case '_expiresAt':
-    key = 'expiresAt';
-    timeField = true;
+    if (valueAsDate(value)) {
+      return {key: 'expiresAt', value: valueAsDate(value)}
+    }
     break;
+  case 'objectId': return {key: '_id', value}
+  case 'sessionToken': return {key: '_session_token', value}
   case '_rperm':
   case '_wperm':
-    return {key: key, value: restValue};
-    break;
+  case '_perishable_token':
+  case '_email_verify_token': return {key, value}
   case '$or':
-    if (!(restValue instanceof Array)) {
+    if (!(value instanceof Array)) {
       throw new Parse.Error(Parse.Error.INVALID_QUERY, 'bad $or format - use an array value');
     }
-    var mongoSubqueries = restValue.map((s) => {
-      return transformWhere(schema, className, s);
-    });
+    var mongoSubqueries = value.map(subQuery => transformWhere(schema, className, subQuery));
     return {key: '$or', value: mongoSubqueries};
   case '$and':
-    if (!(restValue instanceof Array)) {
+    if (!(value instanceof Array)) {
       throw new Parse.Error(Parse.Error.INVALID_QUERY, 'bad $and format - use an array value');
     }
-    var mongoSubqueries = restValue.map((s) => {
-      return transformWhere(schema, className, s);
-    });
+    var mongoSubqueries = value.map(subQuery => transformWhere(schema, className, subQuery));
     return {key: '$and', value: mongoSubqueries};
   default:
     // Other auth data
@@ -190,7 +183,7 @@ function transformQueryKeyValue(schema, className, restKey, restValue, { validat
     if (authDataMatch ) {
       var provider = authDataMatch[1];
       // Special-case auth data.
-      return {key: '_auth_data_'+provider+'.id', value: restValue};
+      return {key: `_auth_data_${provider}.id`, value};
     }
     if (validate && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) {
       throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'invalid key name: ' + key);
@@ -205,46 +198,39 @@ function transformQueryKeyValue(schema, className, restKey, restValue, { validat
     expected = schema.getExpectedType(className, key);
   }
   if ((expected && expected.type == 'Pointer') ||
-      (!expected && restValue && restValue.__type == 'Pointer')) {
+      (!expected && value && value.__type == 'Pointer')) {
     key = '_p_' + key;
   }
   var expectedTypeIsArray = (expected && expected.type === 'Array');
 
   // Handle query constraints
-  value = transformConstraint(restValue, expectedTypeIsArray);
-  if (value !== CannotTransform) {
-    return {key: key, value: value};
+  if (transformConstraint(value, expectedTypeIsArray) !== CannotTransform) {
+    return {key, value: transformConstraint(value, expectedTypeIsArray)};
   }
 
-  if (expectedTypeIsArray && !(restValue instanceof Array)) {
-    return {
-      key: key, value: { '$all' : [restValue] }
-    };
+  if (expectedTypeIsArray && !(value instanceof Array)) {
+    return {key, value: { '$all' : [value] }};
   }
 
   // Handle atomic values
-  var value = transformAtom(restValue, false);
-  if (value !== CannotTransform) {
-    if (timeField && (typeof value === 'string')) {
-      value = new Date(value);
-    }
-    return {key: key, value: value};
+  if (transformAtom(value, false) !== CannotTransform) {
+    return {key, value: transformAtom(value, false)};
   }
 
   // Handle arrays
-  if (restValue instanceof Array) {
-    throw new Parse.Error(Parse.Error.INVALID_JSON,'cannot use array as query param');
+  if (value instanceof Array) {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot use array as query param');
   }
 
   // Handle normal objects by recursing
-  value = {};
-  for (var subRestKey in restValue) {
-    var subRestValue = restValue[subRestKey];
+  let result = {};
+  for (var subRestKey in value) {
+    var subRestValue = value[subRestKey];
     var out = transformKeyValue(schema, className, subRestKey, subRestValue, { inObject: true });
     // For recursed objects, keep the keys in rest format
-    value[subRestKey] = out.value;
+    result[subRestKey] = out.value;
   }
-  return {key: key, value: value};
+  return {key, result};
 }
 
 // Main exposed method to help run queries.
diff --git a/src/Auth.js b/src/Auth.js
index bcee1783..f21bdc76 100644
--- a/src/Auth.js
+++ b/src/Auth.js
@@ -52,11 +52,7 @@ var getAuthForSessionToken = function({ config, sessionToken, installationId } =
     limit: 1,
     include: 'user'
   };
-  var restWhere = {
-    _session_token: sessionToken
-  };
-  var query = new RestQuery(config, master(config), '_Session',
-                            restWhere, restOptions);
+  var query = new RestQuery(config, master(config), '_Session', { sessionToken }, restOptions);
   return query.execute().then((response) => {
     var results = response.results;
     if (results.length !== 1 || !results[0]['user']) {
diff --git a/src/Routers/GlobalConfigRouter.js b/src/Routers/GlobalConfigRouter.js
index c6a82dbb..ab498522 100644
--- a/src/Routers/GlobalConfigRouter.js
+++ b/src/Routers/GlobalConfigRouter.js
@@ -1,12 +1,12 @@
 // global_config.js
 
-import PromiseRouter from '../PromiseRouter';
+import PromiseRouter   from '../PromiseRouter';
 import * as middleware from "../middlewares";
 
 export class GlobalConfigRouter extends PromiseRouter {
   getGlobalConfig(req) {
     let database = req.config.database.WithoutValidation();
-    return database.find('_GlobalConfig', { '_id': 1 }, { limit: 1 }).then((results) => {
+    return database.find('_GlobalConfig', { objectId: 1 }, { limit: 1 }).then((results) => {
       if (results.length != 1) {
         // If there is no config in the database - return empty config.
         return { response: { params: {} } };
diff --git a/src/Routers/SessionsRouter.js b/src/Routers/SessionsRouter.js
index 1a8d8cbf..1bae3344 100644
--- a/src/Routers/SessionsRouter.js
+++ b/src/Routers/SessionsRouter.js
@@ -1,8 +1,8 @@
 
 import ClassesRouter from './ClassesRouter';
 import PromiseRouter from '../PromiseRouter';
-import rest from '../rest';
-import Auth from '../Auth';
+import rest          from '../rest';
+import Auth          from '../Auth';
 
 export class SessionsRouter extends ClassesRouter {
   handleFind(req) {
@@ -36,7 +36,7 @@ export class SessionsRouter extends ClassesRouter {
       throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,
         'Session token required.');
     }
-    return rest.find(req.config, Auth.master(req.config), '_Session', { _session_token: req.info.sessionToken })
+    return rest.find(req.config, Auth.master(req.config), '_Session', { sessionToken: req.info.sessionToken })
       .then((response) => {
         if (!response.results || response.results.length == 0) {
           throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,
diff --git a/src/Routers/UsersRouter.js b/src/Routers/UsersRouter.js
index 4d4cb503..adba752f 100644
--- a/src/Routers/UsersRouter.js
+++ b/src/Routers/UsersRouter.js
@@ -46,7 +46,7 @@ export class UsersRouter extends ClassesRouter {
     }
     let sessionToken = req.info.sessionToken;
     return rest.find(req.config, Auth.master(req.config), '_Session',
-      { _session_token: sessionToken },
+      { sessionToken },
       { include: 'user' })
       .then((response) => {
         if (!response.results ||
@@ -139,7 +139,7 @@ export class UsersRouter extends ClassesRouter {
     let success = {response: {}};
     if (req.info && req.info.sessionToken) {
       return rest.find(req.config, Auth.master(req.config), '_Session',
-        { _session_token: req.info.sessionToken }
+        { sessionToken: req.info.sessionToken }
       ).then((records) => {
         if (records.results && records.results.length) {
           return rest.del(req.config, Auth.master(req.config), '_Session',