Removes dependency upon babel-polyfills (#2731)

flovilmart · web-flow · commit 2ec2bb5660bd · 2016-09-24T13:53:15.000-04:00
* Removes runtime dependency babel-polyfill (#2692) * Removes runtime dependency babel-polyfill * removes references to polyfilled array includes * Better support for polyfilling * Removes unnecessary log * Adds killswitch if tests are polyfilled * Reverts usage of includes on strings
diff --git a/package.json b/package.json
@@ -18,7 +18,6 @@
   ],
   "license": "BSD-3-Clause",
   "dependencies": {
-    "babel-polyfill": "6.13.0",
     "bcryptjs": "2.3.0",
     "body-parser": "1.15.2",
     "commander": "2.9.0",
@@ -66,10 +65,10 @@
   "scripts": {
     "dev": "npm run build && node bin/dev",
     "build": "babel src/ -d lib/",
-    "test": "cross-env MONGODB_VERSION=${MONGODB_VERSION:=3.2.6} MONGODB_STORAGE_ENGINE=mmapv1 NODE_ENV=test TESTING=1 babel-node $COVERAGE_OPTION ./node_modules/jasmine/bin/jasmine.js",
-    "test:win": "npm run pretest && cross-env NODE_ENV=test TESTING=1 babel-node ./node_modules/jasmine/bin/jasmine.js && npm run posttest",
+    "test": "cross-env MONGODB_VERSION=${MONGODB_VERSION:=3.2.6} MONGODB_STORAGE_ENGINE=mmapv1 NODE_ENV=test TESTING=1 node $COVERAGE_OPTION ./node_modules/jasmine/bin/jasmine.js",
+    "test:win": "npm run pretest && cross-env NODE_ENV=test TESTING=1 node ./node_modules/jasmine/bin/jasmine.js && npm run posttest",
     "coverage": "cross-env COVERAGE_OPTION='./node_modules/.bin/istanbul cover' npm test",
-    "coverage:win": "npm run pretest && cross-env NODE_ENV=test TESTING=1 babel-node ./node_modules/babel-istanbul/lib/cli.js cover ./node_modules/jasmine/bin/jasmine.js && npm run posttest",
+    "coverage:win": "npm run pretest && cross-env NODE_ENV=test TESTING=1 node ./node_modules/babel-istanbul/lib/cli.js cover ./node_modules/jasmine/bin/jasmine.js && npm run posttest",
     "start": "node ./bin/parse-server",
     "prepublish": "npm run build"
   },
diff --git a/spec/helper.js b/spec/helper.js
@@ -14,6 +14,11 @@ global.on_db = (db, callback, elseCallback) => {
   }
 }
 
+if (global._babelPolyfill) {
+  console.error('We should not use polyfilled tests');
+  process.exit(1);
+}
+
 var cache = require('../src/cache').default;
 var express = require('express');
 var facebook = require('../src/authDataManager/facebook');
@@ -214,7 +219,7 @@ afterEach(function(done) {
         } else {
           // Other system classes will break Parse.com, so make sure that we don't save anything to _SCHEMA that will
           // break it.
-          return ['_User', '_Installation', '_Role', '_Session', '_Product'].includes(className);
+          return ['_User', '_Installation', '_Role', '_Session', '_Product'].indexOf(className) >= 0;
         }
       }});
     });
@@ -387,15 +392,15 @@ global.jfail = function(err) {
 }
 
 global.it_exclude_dbs = excluded => {
-  if (excluded.includes(process.env.PARSE_SERVER_TEST_DB)) {
+  if (excluded.indexOf(process.env.PARSE_SERVER_TEST_DB) >= 0) {
     return xit;
   } else {
     return it;
   }
 }
 
 global.fit_exclude_dbs = excluded => {
-  if (excluded.includes(process.env.PARSE_SERVER_TEST_DB)) {
+  if (excluded.indexOf(process.env.PARSE_SERVER_TEST_DB) >= 0) {
     return xit;
   } else {
     return fit;
diff --git a/src/Adapters/Storage/Mongo/MongoTransform.js b/src/Adapters/Storage/Mongo/MongoTransform.js
@@ -101,7 +101,7 @@ const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSc
 }
 
 const transformInteriorValue = restValue => {
-  if (restValue !== null && typeof restValue === 'object' && Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))) {
+  if (restValue !== null && typeof restValue === 'object' && Object.keys(restValue).some(key => key.includes('$')|| key.includes('.'))) {
     throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters");
   }
   // Handle atomic values
diff --git a/src/Adapters/Storage/Postgres/PostgresStorageAdapter.js b/src/Adapters/Storage/Postgres/PostgresStorageAdapter.js
@@ -445,7 +445,7 @@ export class PostgresStorageAdapter {
         relations.push(fieldName)
         return;
       }
-      if (['_rperm', '_wperm'].includes(fieldName)) {
+      if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) {
         parseType.contents = { type: 'String' };
       }
       valuesArray.push(fieldName);
@@ -678,7 +678,7 @@ export class PostgresStorageAdapter {
           valuesArray.push(object[fieldName].objectId);
           break;
         case 'Array':
-          if (['_rperm', '_wperm'].includes(fieldName)) {
+          if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) {
             valuesArray.push(object[fieldName]);
           } else {
             valuesArray.push(JSON.stringify(object[fieldName]));
@@ -707,7 +707,7 @@ export class PostgresStorageAdapter {
     let initialValues = valuesArray.map((val, index) => {
       let termination = '';
       let fieldName = columnsArray[index];
-      if (['_rperm','_wperm'].includes(fieldName)) {
+      if (['_rperm','_wperm'].indexOf(fieldName) >= 0) {
         termination = '::text[]';
       } else if (schema.fields[fieldName] && schema.fields[fieldName].type === 'Array') {
         termination = '::jsonb';
diff --git a/src/Controllers/DatabaseController.js b/src/Controllers/DatabaseController.js
@@ -44,6 +44,11 @@ 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 => {
+  return specialQuerykeys.indexOf(key) >= 0;
+}
+
 const validateQuery = query => {
   if (query.ACL) {
     throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Cannot query on ACL.');
@@ -73,7 +78,7 @@ const validateQuery = query => {
         }
       }
     }
-    if (!specialQuerykeys.includes(key) && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) {
+    if (!isSpecialQueryKey(key) && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) {
       throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid key name: ${key}`);
     }
   });
@@ -185,6 +190,11 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => {
 //         one of the provided strings must provide the caller with
 //         write permissions.
 const specialKeysForUpdate = ['_hashed_password', '_perishable_token', '_email_verify_token', '_email_verify_token_expires_at', '_account_lockout_expires_at', '_failed_login_count'];
+
+const isSpecialUpdateKey = key => {
+  return specialKeysForUpdate.indexOf(key) >= 0;
+}
+
 DatabaseController.prototype.update = function(className, query, update, {
   acl,
   many,
@@ -227,7 +237,7 @@ DatabaseController.prototype.update = function(className, query, update, {
             throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);
           }
           fieldName = fieldName.split('.')[0];
-          if (!SchemaController.fieldNameIsValid(fieldName) && !specialKeysForUpdate.includes(fieldName)) {
+          if (!SchemaController.fieldNameIsValid(fieldName) && !isSpecialUpdateKey(fieldName)) {
             throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);
           }
         });
diff --git a/src/Controllers/SchemaController.js b/src/Controllers/SchemaController.js
@@ -218,7 +218,7 @@ const validNonRelationOrPointerTypes = [
 ];
 // Returns an error suitable for throwing if the type is invalid
 const fieldTypeIsInvalid = ({ type, targetClass }) => {
-  if (['Pointer', 'Relation'].includes(type)) {
+  if (['Pointer', 'Relation'].indexOf(type) >= 0) {
     if (!targetClass) {
       return new Parse.Error(135, `type ${type} needs a class name`);
     } else if (typeof targetClass !== 'string') {
@@ -232,7 +232,7 @@ const fieldTypeIsInvalid = ({ type, targetClass }) => {
    if (typeof type !== 'string') {
     return invalidJsonError;
    }
-  if (!validNonRelationOrPointerTypes.includes(type)) {
+  if (validNonRelationOrPointerTypes.indexOf(type) < 0) {
     return new Parse.Error(Parse.Error.INCORRECT_TYPE, `invalid field type: ${type}`);
    }
   return undefined;
@@ -520,7 +520,6 @@ export default class SchemaController {
       }
     })
     .catch(error => {
-      console.error(error);
       // The schema still doesn't validate. Give up
       throw new Parse.Error(Parse.Error.INVALID_JSON, 'schema class name does not revalidate');
     });
@@ -541,7 +540,7 @@ export default class SchemaController {
 
   validateSchemaData(className, fields, classLevelPermissions, existingFieldNames) {
     for (let fieldName in fields) {
-      if (!existingFieldNames.includes(fieldName)) {
+      if (existingFieldNames.indexOf(fieldName) < 0) {
         if (!fieldNameIsValid(fieldName)) {
           return {
             code: Parse.Error.INVALID_KEY_NAME,
diff --git a/src/LiveQuery/ParseLiveQueryServer.js b/src/LiveQuery/ParseLiveQueryServer.js
@@ -8,6 +8,7 @@ import RequestSchema from './RequestSchema';
 import { matchesQuery, queryHash } from './QueryTools';
 import { ParsePubSub } from './ParsePubSub';
 import { SessionTokenCache } from './SessionTokenCache';
+import _ from 'lodash';
 
 class ParseLiveQueryServer {
   clientId: number;
@@ -122,7 +123,7 @@ class ParseLiveQueryServer {
       if (!isSubscriptionMatched) {
         continue;
       }
-      for (let [clientId, requestIds] of subscription.clientRequestIds.entries()) {
+      for (let [clientId, requestIds] of _.entries(subscription.clientRequestIds)) {
         let client = this.clients.get(clientId);
         if (typeof client === 'undefined') {
           continue;
@@ -165,7 +166,7 @@ class ParseLiveQueryServer {
     for (let subscription of classSubscriptions.values()) {
       let isOriginalSubscriptionMatched = this._matchesSubscription(originalParseObject, subscription);
       let isCurrentSubscriptionMatched = this._matchesSubscription(currentParseObject, subscription);
-      for (let [clientId, requestIds] of subscription.clientRequestIds.entries()) {
+      for (let [clientId, requestIds] of _.entries(subscription.clientRequestIds)) {
         let client = this.clients.get(clientId);
         if (typeof client === 'undefined') {
           continue;
@@ -280,7 +281,7 @@ class ParseLiveQueryServer {
       this.clients.delete(clientId);
 
       // Delete client from subscriptions
-      for (let [requestId, subscriptionInfo] of client.subscriptionInfos.entries()) {
+      for (let [requestId, subscriptionInfo] of _.entries(client.subscriptionInfos)) {
         let subscription = subscriptionInfo.subscription;
         subscription.deleteClientSubscription(clientId, requestId);
 
diff --git a/src/ParseServer.js b/src/ParseServer.js
@@ -9,10 +9,6 @@ var batch = require('./batch'),
     path = require('path'),
     authDataManager = require('./authDataManager');
 
-if (!global._babelPolyfill) {
-  require('babel-polyfill');
-}
-
 import defaults                 from './defaults';
 import * as logging             from './logger';
 import AppCache                 from './cache';
diff --git a/src/Routers/ClassesRouter.js b/src/Routers/ClassesRouter.js
@@ -1,7 +1,7 @@
 
 import PromiseRouter from '../PromiseRouter';
 import rest          from '../rest';
-
+import _             from 'lodash';
 import url           from 'url';
 
 const ALLOWED_GET_QUERY_KEYS = ['keys', 'include'];
@@ -115,7 +115,7 @@ export class ClassesRouter extends PromiseRouter {
 
   static JSONFromQuery(query) {
     let json = {};
-    for (let [key, value] of Object.entries(query)) {
+    for (let [key, value] of _.entries(query)) {
       try {
         json[key] = JSON.parse(value);
       } catch (e) {

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,11 @@ global.on_db = (db, callback, elseCallback) => {`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
	`17`	`+if (global._babelPolyfill) {`
	`18`	`+ console.error('We should not use polyfilled tests');`
	`19`	`+ process.exit(1);`
	`20`	`+}`
	`21`	`+`
`17`	`22`	`var cache = require('../src/cache').default;`
`18`	`23`	`var express = require('express');`
`19`	`24`	`var facebook = require('../src/authDataManager/facebook');`
`@@ -214,7 +219,7 @@ afterEach(function(done) {`
`214`	`219`	`} else {`
`215`	`220`	`// Other system classes will break Parse.com, so make sure that we don't save anything to _SCHEMA that will`
`216`	`221`	`// break it.`
`217`		`- return ['_User', '_Installation', '_Role', '_Session', '_Product'].includes(className);`
	`222`	`+ return ['_User', '_Installation', '_Role', '_Session', '_Product'].indexOf(className) >= 0;`
`218`	`223`	`}`
`219`	`224`	`}});`
`220`	`225`	`});`
`@@ -387,15 +392,15 @@ global.jfail = function(err) {`
`387`	`392`	`}`
`388`	`393`
`389`	`394`	`global.it_exclude_dbs = excluded => {`
`390`		`- if (excluded.includes(process.env.PARSE_SERVER_TEST_DB)) {`
	`395`	`+ if (excluded.indexOf(process.env.PARSE_SERVER_TEST_DB) >= 0) {`
`391`	`396`	`return xit;`
`392`	`397`	`} else {`
`393`	`398`	`return it;`
`394`	`399`	`}`
`395`	`400`	`}`
`396`	`401`
`397`	`402`	`global.fit_exclude_dbs = excluded => {`
`398`		`- if (excluded.includes(process.env.PARSE_SERVER_TEST_DB)) {`
	`403`	`+ if (excluded.indexOf(process.env.PARSE_SERVER_TEST_DB) >= 0) {`
`399`	`404`	`return xit;`
`400`	`405`	`} else {`
`401`	`406`	`return fit;`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSc`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`const transformInteriorValue = restValue => {`
`104`		`- if (restValue !== null && typeof restValue === 'object' && Object.keys(restValue).some(key => key.includes('$') \|\| key.includes('.'))) {`
	`104`	`+ if (restValue !== null && typeof restValue === 'object' && Object.keys(restValue).some(key => key.includes('$')\|\| key.includes('.'))) {`
`105`	`105`	`throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters");`
`106`	`106`	`}`
`107`	`107`	`// Handle atomic values`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,11 @@ const transformObjectACL = ({ ACL, ...result }) => {`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`const specialQuerykeys = ['$and', '$or', '_rperm', '_wperm', '_perishable_token', '_email_verify_token', '_email_verify_token_expires_at', '_account_lockout_expires_at', '_failed_login_count'];`
	`47`	`+`
	`48`	`+const isSpecialQueryKey = key => {`
	`49`	`+ return specialQuerykeys.indexOf(key) >= 0;`
	`50`	`+}`
	`51`	`+`
`47`	`52`	`const validateQuery = query => {`
`48`	`53`	`if (query.ACL) {`
`49`	`54`	`throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Cannot query on ACL.');`
`@@ -73,7 +78,7 @@ const validateQuery = query => {`
`73`	`78`	`}`
`74`	`79`	`}`
`75`	`80`	`}`
`76`		`- if (!specialQuerykeys.includes(key) && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) {`
	`81`	`+ if (!isSpecialQueryKey(key) && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) {`
`77`	`82`	throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid key name: ${key}`);
`78`	`83`	`}`
`79`	`84`	`});`
`@@ -185,6 +190,11 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => {`
`185`	`190`	`// one of the provided strings must provide the caller with`
`186`	`191`	`// write permissions.`
`187`	`192`	`const specialKeysForUpdate = ['_hashed_password', '_perishable_token', '_email_verify_token', '_email_verify_token_expires_at', '_account_lockout_expires_at', '_failed_login_count'];`
	`193`	`+`
	`194`	`+const isSpecialUpdateKey = key => {`
	`195`	`+ return specialKeysForUpdate.indexOf(key) >= 0;`
	`196`	`+}`
	`197`	`+`
`188`	`198`	`DatabaseController.prototype.update = function(className, query, update, {`
`189`	`199`	`acl,`
`190`	`200`	`many,`
`@@ -227,7 +237,7 @@ DatabaseController.prototype.update = function(className, query, update, {`
`227`	`237`	throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);
`228`	`238`	`}`
`229`	`239`	`fieldName = fieldName.split('.')[0];`
`230`		`- if (!SchemaController.fieldNameIsValid(fieldName) && !specialKeysForUpdate.includes(fieldName)) {`
	`240`	`+ if (!SchemaController.fieldNameIsValid(fieldName) && !isSpecialUpdateKey(fieldName)) {`
`231`	`241`	throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);
`232`	`242`	`}`
`233`	`243`	`});`