Deploy master to LATEST branch

Author: Travis CI

CHANGELOG.md

@@ -0,0 +1,30 @@
+BSD License
+
+For Parse Server software
+
+Copyright (c) 2015-present, Parse, LLC. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name Parse nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

LICENSE

@@ -0,0 +1,33 @@
+Additional Grant of Patent Rights Version 2
+
+"Software" means the Parse Server software distributed by Parse, LLC.
+
+Parse, LLC. ("Parse") hereby grants to each recipient of the Software
+("you") a perpetual, worldwide, royalty-free, non-exclusive, irrevocable
+(subject to the termination provision below) license under any Necessary
+Claims, to make, have made, use, sell, offer to sell, import, and otherwise
+transfer the Software. For avoidance of doubt, no license is granted under
+Parse’s rights in any patent claims that are infringed by (i) modifications
+to the Software made by you or any third party or (ii) the Software in
+combination with any software or other technology.
+
+The license granted hereunder will terminate, automatically and without notice,
+if you (or any of your subsidiaries, corporate affiliates or agents) initiate
+directly or indirectly, or take a direct financial interest in, any Patent
+Assertion: (i) against Parse or any of its subsidiaries or corporate
+affiliates, (ii) against any party if such Patent Assertion arises in whole or
+in part from any software, technology, product or service of Parse or any of
+its subsidiaries or corporate affiliates, or (iii) against any party relating
+to the Software. Notwithstanding the foregoing, if Parse or any of its
+subsidiaries or corporate affiliates files a lawsuit alleging patent
+infringement against you in the first instance, and you respond by filing a
+patent infringement counterclaim in that lawsuit against that party that is
+unrelated to the Software, the license granted hereunder will not terminate
+under section (i) of this paragraph due to such counterclaim.
+
+A "Necessary Claim" is a claim of a patent owned by Parse that is
+necessarily infringed by the Software standing alone.
+
+A "Patent Assertion" is any lawsuit or other action alleging direct, indirect,
+or contributory infringement or inducement to infringe any patent, including a
+cross-claim or counterclaim.

PATENTS

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+var nodemon = require('nodemon');
+var babel = require("babel-core");
+var gaze = require('gaze'); 
+var fs = require('fs');
+var path = require('path');
+
+// Watch the src and transpile when changed
+gaze('src/**/*', function(err, watcher) {
+  if (err) throw err;
+  watcher.on('changed', function(sourceFile) {
+    console.log(sourceFile + " has changed");
+    try {
+      targetFile = path.relative(__dirname, sourceFile).replace(/\/src\//, '/lib/');
+      targetFile = path.resolve(__dirname, targetFile);
+      fs.writeFile(targetFile, babel.transformFileSync(sourceFile).code);
+    } catch (e) {
+      console.error(e.message, e.stack);
+    }
+  });
+});
+
+try {
+  // Run and watch dist 
+  nodemon({
+    script: 'bin/parse-server',
+    ext: 'js json',
+    watch: 'lib'
+  });
+} catch (e) {
+  console.error(e.message, e.stack);
+}
+
+process.once('SIGINT', function() {
+    process.exit(0);
+});

README.md

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/cli/parse-live-query-server");

bin/dev

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/cli/parse-server");

bin/parse-live-query-server

@@ -0,0 +1,238 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountLockout = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // This class handles the Account Lockout Policy settings.
+
+var _Config = require('./Config');
+
+var _Config2 = _interopRequireDefault(_Config);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var AccountLockout = exports.AccountLockout = function () {
+  function AccountLockout(user, config) {
+    _classCallCheck(this, AccountLockout);
+
+    this._user = user;
+    this._config = config;
+  }
+
+  /**
+   * set _failed_login_count to value
+   */
+
+
+  _createClass(AccountLockout, [{
+    key: '_setFailedLoginCount',
+    value: function _setFailedLoginCount(value) {
+      var query = {
+        username: this._user.username
+      };
+
+      var updateFields = {
+        _failed_login_count: value
+      };
+
+      return this._config.database.update('_User', query, updateFields);
+    }
+
+    /**
+     * check if the _failed_login_count field has been set
+     */
+
+  }, {
+    key: '_isFailedLoginCountSet',
+    value: function _isFailedLoginCountSet() {
+      var _this = this;
+
+      return new Promise(function (resolve, reject) {
+        var query = {
+          username: _this._user.username,
+          _failed_login_count: { $exists: true }
+        };
+
+        _this._config.database.find('_User', query).then(function (users) {
+          if (Array.isArray(users) && users.length > 0) {
+            resolve(true);
+          } else {
+            resolve(false);
+          }
+        }).catch(function (err) {
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * if _failed_login_count is NOT set then set it to 0
+     * else do nothing
+     */
+
+  }, {
+    key: '_initFailedLoginCount',
+    value: function _initFailedLoginCount() {
+      var _this2 = this;
+
+      return new Promise(function (resolve, reject) {
+
+        _this2._isFailedLoginCountSet().then(function (failedLoginCountIsSet) {
+          if (!failedLoginCountIsSet) {
+            return _this2._setFailedLoginCount(0);
+          } else {
+            return Promise.resolve();
+          }
+        }).then(function () {
+          resolve();
+        }).catch(function (err) {
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * increment _failed_login_count by 1
+     */
+
+  }, {
+    key: '_incrementFailedLoginCount',
+    value: function _incrementFailedLoginCount() {
+      var query = {
+        username: this._user.username
+      };
+
+      var updateFields = { _failed_login_count: { __op: 'Increment', amount: 1 } };
+
+      return this._config.database.update('_User', query, updateFields);
+    }
+
+    /**
+     * if the failed login count is greater than the threshold 
+     * then sets lockout expiration to 'currenttime + accountPolicy.duration', i.e., account is locked out for the next 'accountPolicy.duration' minutes 
+     * else do nothing
+     */
+
+  }, {
+    key: '_setLockoutExpiration',
+    value: function _setLockoutExpiration() {
+      var _this3 = this;
+
+      return new Promise(function (resolve, reject) {
+        var query = {
+          username: _this3._user.username,
+          _failed_login_count: { $gte: _this3._config.accountLockout.threshold }
+        };
+
+        var now = new Date();
+
+        var updateFields = {
+          _account_lockout_expires_at: Parse._encode(new Date(now.getTime() + _this3._config.accountLockout.duration * 60 * 1000))
+        };
+
+        _this3._config.database.update('_User', query, updateFields).then(function () {
+          resolve();
+        }).catch(function (err) {
+          if (err && err.code && err.message && err.code === 101 && err.message === 'Object not found.') {
+            resolve(); // nothing to update so we are good
+          } else {
+            reject(err); // unknown error
+          }
+        });
+      });
+    }
+
+    /**
+     * if _account_lockout_expires_at > current_time and _failed_login_count > threshold
+     *   reject with account locked error
+     * else
+     *   resolve
+     */
+
+  }, {
+    key: '_notLocked',
+    value: function _notLocked() {
+      var _this4 = this;
+
+      return new Promise(function (resolve, reject) {
+        var query = {
+          username: _this4._user.username,
+          _account_lockout_expires_at: { $gt: Parse._encode(new Date()) },
+          _failed_login_count: { $gte: _this4._config.accountLockout.threshold }
+        };
+
+        _this4._config.database.find('_User', query).then(function (users) {
+          if (Array.isArray(users) && users.length > 0) {
+            reject(new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Your account is locked due to multiple failed login attempts. Please try again after ' + _this4._config.accountLockout.duration + ' minute(s)'));
+          } else {
+            resolve();
+          }
+        }).catch(function (err) {
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * set and/or increment _failed_login_count
+     * if _failed_login_count > threshold
+     *   set the _account_lockout_expires_at to current_time + accountPolicy.duration
+     * else 
+     *   do nothing   
+     */
+
+  }, {
+    key: '_handleFailedLoginAttempt',
+    value: function _handleFailedLoginAttempt() {
+      var _this5 = this;
+
+      return new Promise(function (resolve, reject) {
+        _this5._initFailedLoginCount().then(function () {
+          return _this5._incrementFailedLoginCount();
+        }).then(function () {
+          return _this5._setLockoutExpiration();
+        }).then(function () {
+          resolve();
+        }).catch(function (err) {
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * handle login attempt if the Account Lockout Policy is enabled
+     */
+
+  }, {
+    key: 'handleLoginAttempt',
+    value: function handleLoginAttempt(loginSuccessful) {
+      var _this6 = this;
+
+      if (!this._config.accountLockout) {
+        return Promise.resolve();
+      }
+
+      return new Promise(function (resolve, reject) {
+        _this6._notLocked().then(function () {
+          if (loginSuccessful) {
+            return _this6._setFailedLoginCount(0);
+          } else {
+            return _this6._handleFailedLoginAttempt();
+          }
+        }).then(function () {
+          resolve();
+        }).catch(function (err) {
+          reject(err);
+        });
+      });
+    }
+  }]);
+
+  return AccountLockout;
+}();
+
+exports.default = AccountLockout;

bin/parse-server

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadAdapter = loadAdapter;
+function loadAdapter(adapter, defaultAdapter, options) {
+  if (!adapter) {
+    if (!defaultAdapter) {
+      return options;
+    }
+    // Load from the default adapter when no adapter is set
+    return loadAdapter(defaultAdapter, undefined, options);
+  } else if (typeof adapter === "function") {
+    try {
+      return adapter(options);
+    } catch (e) {
+      if (e.name === 'TypeError') {
+        var Adapter = adapter;
+        return new Adapter(options);
+      } else {
+        throw e;
+      }
+    }
+  } else if (typeof adapter === "string") {
+    adapter = require(adapter);
+    // If it's define as a module, get the default
+    if (adapter.default) {
+      adapter = adapter.default;
+    }
+    return loadAdapter(adapter, undefined, options);
+  } else if (adapter.module) {
+    return loadAdapter(adapter.module, undefined, adapter.options);
+  } else if (adapter.class) {
+    return loadAdapter(adapter.class, undefined, adapter.options);
+  } else if (adapter.adapter) {
+    return loadAdapter(adapter.adapter, undefined, adapter.options);
+  }
+  // return the adapter as provided
+  return adapter;
+}
+
+exports.default = loadAdapter;