From a2127f720891d3f23dbfb08fd8927bb88f015ae5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ant=C3=B4nio=20Davi=20Mac=C3=AAdo=20Co=C3=AAlho=20de=20Cas?= =?UTF-8?q?tro?= Date: Wed, 24 May 2017 15:52:46 -0300 Subject: [PATCH 01/73] To merge --- .gitignore | 2 +- lib/AccountLockout.js | 159 ++ lib/Adapters/AdapterLoader.js | 44 + lib/Adapters/Analytics/AnalyticsAdapter.js | 28 + lib/Adapters/Auth/AuthAdapter.js | 28 + lib/Adapters/Auth/OAuth1Client.js | 222 +++ lib/Adapters/Auth/facebook.js | 56 + lib/Adapters/Auth/github.js | 54 + lib/Adapters/Auth/google.js | 70 + lib/Adapters/Auth/index.js | 121 ++ lib/Adapters/Auth/instagram.js | 43 + lib/Adapters/Auth/janraincapture.js | 55 + lib/Adapters/Auth/janrainengage.js | 73 + lib/Adapters/Auth/linkedin.js | 60 + lib/Adapters/Auth/meetup.js | 53 + lib/Adapters/Auth/qq.js | 53 + lib/Adapters/Auth/spotify.js | 62 + lib/Adapters/Auth/twitter.js | 56 + lib/Adapters/Auth/vkontakte.js | 67 + lib/Adapters/Auth/wechat.js | 47 + lib/Adapters/Auth/weibo.js | 66 + lib/Adapters/Cache/CacheAdapter.js | 34 + lib/Adapters/Cache/InMemoryCache.js | 70 + lib/Adapters/Cache/InMemoryCacheAdapter.js | 41 + lib/Adapters/Cache/LRUCache.js | 48 + lib/Adapters/Cache/NullCacheAdapter.js | 30 + lib/Adapters/Cache/RedisCacheAdapter.js | 99 + lib/Adapters/Email/MailAdapter.js | 29 + lib/Adapters/Files/FilesAdapter.js | 60 + lib/Adapters/Files/GridStoreAdapter.js | 89 + lib/Adapters/Logger/LoggerAdapter.js | 22 + lib/Adapters/Logger/WinstonLogger.js | 125 ++ lib/Adapters/Logger/WinstonLoggerAdapter.js | 71 + lib/Adapters/MessageQueue/EventEmitterMQ.js | 72 + lib/Adapters/PubSub/EventEmitterPubSub.js | 65 + lib/Adapters/PubSub/RedisPubSub.js | 68 + lib/Adapters/Push/PushAdapter.js | 32 + lib/Adapters/Storage/Mongo/MongoCollection.js | 112 ++ .../Storage/Mongo/MongoSchemaCollection.js | 227 +++ .../Storage/Mongo/MongoStorageAdapter.js | 578 ++++++ lib/Adapters/Storage/Mongo/MongoTransform.js | 1314 +++++++++++++ .../Storage/Postgres/PostgresClient.js | 33 + .../Storage/Postgres/PostgresConfigParser.js | 46 + .../Postgres/PostgresStorageAdapter.js | 1660 +++++++++++++++++ .../Storage/Postgres/sql/array/add-unique.sql | 11 + .../Storage/Postgres/sql/array/add.sql | 11 + .../Postgres/sql/array/contains-all.sql | 11 + .../Storage/Postgres/sql/array/contains.sql | 11 + .../Storage/Postgres/sql/array/remove.sql | 11 + lib/Adapters/Storage/Postgres/sql/index.js | 32 + .../sql/misc/json-object-set-keys.sql | 19 + lib/Auth.js | 221 +++ lib/ClientSDK.js | 42 + lib/Config.js | 292 +++ lib/Controllers/AdaptableController.js | 86 + lib/Controllers/AnalyticsController.js | 43 + lib/Controllers/CacheController.js | 91 + lib/Controllers/DatabaseController.js | 1016 ++++++++++ lib/Controllers/FilesController.js | 108 ++ lib/Controllers/HooksController.js | 237 +++ lib/Controllers/LiveQueryController.js | 58 + lib/Controllers/LoggerController.js | 243 +++ lib/Controllers/PushController.js | 212 +++ lib/Controllers/SchemaCache.js | 96 + lib/Controllers/SchemaController.js | 1048 +++++++++++ lib/Controllers/UserController.js | 259 +++ lib/Controllers/index.js | 282 +++ lib/LiveQuery/Client.js | 97 + lib/LiveQuery/Id.js | 22 + lib/LiveQuery/ParseCloudCodePublisher.js | 50 + lib/LiveQuery/ParseLiveQueryServer.js | 580 ++++++ lib/LiveQuery/ParsePubSub.js | 45 + lib/LiveQuery/ParseWebSocketServer.js | 62 + lib/LiveQuery/QueryTools.js | 320 ++++ lib/LiveQuery/RequestSchema.js | 145 ++ lib/LiveQuery/SessionTokenCache.js | 63 + lib/LiveQuery/Subscription.js | 55 + lib/LiveQuery/equalObjects.js | 50 + lib/Options/Definitions.js | 388 ++++ lib/Options/index.js | 1 + lib/Options/parsers.js | 77 + lib/ParseMessageQueue.js | 30 + lib/ParseServer.js | 375 ++++ lib/ParseServerRESTController.js | 103 + lib/PromiseRouter.js | 218 +++ lib/Push/PushQueue.js | 72 + lib/Push/PushWorker.js | 149 ++ lib/Push/utils.js | 133 ++ lib/RestQuery.js | 752 ++++++++ lib/RestWrite.js | 1178 ++++++++++++ lib/Routers/AggregateRouter.js | 82 + lib/Routers/AnalyticsRouter.js | 31 + lib/Routers/AudiencesRouter.js | 72 + lib/Routers/ClassesRouter.js | 169 ++ lib/Routers/CloudCodeRouter.js | 95 + lib/Routers/ExportRouter.js | 212 +++ lib/Routers/FeaturesRouter.js | 75 + lib/Routers/FilesRouter.js | 205 ++ lib/Routers/FunctionsRouter.js | 183 ++ lib/Routers/GlobalConfigRouter.js | 61 + lib/Routers/HooksRouter.js | 117 ++ lib/Routers/IAPValidationRouter.js | 125 ++ lib/Routers/ImportRouter.js | 208 +++ lib/Routers/InstallationsRouter.js | 53 + lib/Routers/LogsRouter.js | 71 + lib/Routers/PublicAPIRouter.js | 271 +++ lib/Routers/PurgeRouter.js | 42 + lib/Routers/PushRouter.js | 88 + lib/Routers/RolesRouter.js | 39 + lib/Routers/SchemasRouter.js | 96 + lib/Routers/SessionsRouter.js | 116 ++ lib/Routers/UsersRouter.js | 325 ++++ lib/StatusHandler.js | 324 ++++ lib/TestUtils.js | 27 + lib/batch.js | 98 + lib/cache.js | 11 + .../definitions/parse-live-query-server.js | 7 + lib/cli/definitions/parse-server.js | 7 + lib/cli/parse-live-query-server.js | 21 + lib/cli/parse-server.js | 98 + lib/cli/utils/commander.js | 140 ++ lib/cli/utils/runner.js | 53 + lib/cloud-code/HTTPResponse.js | 56 + lib/cloud-code/Parse.Cloud.js | 72 + lib/cloud-code/httpRequest.js | 101 + lib/cryptoUtils.js | 58 + lib/defaults.js | 43 + lib/deprecated.js | 11 + lib/index.js | 77 + lib/logger.js | 47 + lib/middlewares.js | 344 ++++ lib/password.js | 29 + lib/requiredParameter.js | 9 + lib/rest.js | 180 ++ lib/triggers.js | 467 +++++ lib/vendor/README.md | 8 + lib/vendor/mongodbUrl.js | 924 +++++++++ package.json | 3 + spec/Export.spec.js | 139 ++ spec/Import.spec.js | 460 +++++ src/Adapters/PubSub/RedisPubSub.js | 52 +- src/Controllers/SchemaController.js | 10 +- src/ParseServer.js | 4 + src/Push/PushWorker.js | 30 +- src/RestQuery.js | 12 +- src/RestWrite.js | 5 +- src/Routers/ExportRouter.js | 212 +++ src/Routers/FeaturesRouter.js | 3 +- src/Routers/ImportRouter.js | 219 +++ src/middlewares.js | 2 +- src/rest.js | 4 +- 151 files changed, 22829 insertions(+), 23 deletions(-) create mode 100644 lib/AccountLockout.js create mode 100644 lib/Adapters/AdapterLoader.js create mode 100644 lib/Adapters/Analytics/AnalyticsAdapter.js create mode 100644 lib/Adapters/Auth/AuthAdapter.js create mode 100644 lib/Adapters/Auth/OAuth1Client.js create mode 100644 lib/Adapters/Auth/facebook.js create mode 100644 lib/Adapters/Auth/github.js create mode 100644 lib/Adapters/Auth/google.js create mode 100755 lib/Adapters/Auth/index.js create mode 100644 lib/Adapters/Auth/instagram.js create mode 100644 lib/Adapters/Auth/janraincapture.js create mode 100644 lib/Adapters/Auth/janrainengage.js create mode 100644 lib/Adapters/Auth/linkedin.js create mode 100644 lib/Adapters/Auth/meetup.js create mode 100644 lib/Adapters/Auth/qq.js create mode 100644 lib/Adapters/Auth/spotify.js create mode 100644 lib/Adapters/Auth/twitter.js create mode 100644 lib/Adapters/Auth/vkontakte.js create mode 100644 lib/Adapters/Auth/wechat.js create mode 100644 lib/Adapters/Auth/weibo.js create mode 100644 lib/Adapters/Cache/CacheAdapter.js create mode 100644 lib/Adapters/Cache/InMemoryCache.js create mode 100644 lib/Adapters/Cache/InMemoryCacheAdapter.js create mode 100644 lib/Adapters/Cache/LRUCache.js create mode 100644 lib/Adapters/Cache/NullCacheAdapter.js create mode 100644 lib/Adapters/Cache/RedisCacheAdapter.js create mode 100644 lib/Adapters/Email/MailAdapter.js create mode 100644 lib/Adapters/Files/FilesAdapter.js create mode 100644 lib/Adapters/Files/GridStoreAdapter.js create mode 100644 lib/Adapters/Logger/LoggerAdapter.js create mode 100644 lib/Adapters/Logger/WinstonLogger.js create mode 100644 lib/Adapters/Logger/WinstonLoggerAdapter.js create mode 100644 lib/Adapters/MessageQueue/EventEmitterMQ.js create mode 100644 lib/Adapters/PubSub/EventEmitterPubSub.js create mode 100644 lib/Adapters/PubSub/RedisPubSub.js create mode 100644 lib/Adapters/Push/PushAdapter.js create mode 100644 lib/Adapters/Storage/Mongo/MongoCollection.js create mode 100644 lib/Adapters/Storage/Mongo/MongoSchemaCollection.js create mode 100644 lib/Adapters/Storage/Mongo/MongoStorageAdapter.js create mode 100644 lib/Adapters/Storage/Mongo/MongoTransform.js create mode 100644 lib/Adapters/Storage/Postgres/PostgresClient.js create mode 100644 lib/Adapters/Storage/Postgres/PostgresConfigParser.js create mode 100644 lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js create mode 100644 lib/Adapters/Storage/Postgres/sql/array/add-unique.sql create mode 100644 lib/Adapters/Storage/Postgres/sql/array/add.sql create mode 100644 lib/Adapters/Storage/Postgres/sql/array/contains-all.sql create mode 100644 lib/Adapters/Storage/Postgres/sql/array/contains.sql create mode 100644 lib/Adapters/Storage/Postgres/sql/array/remove.sql create mode 100644 lib/Adapters/Storage/Postgres/sql/index.js create mode 100644 lib/Adapters/Storage/Postgres/sql/misc/json-object-set-keys.sql create mode 100644 lib/Auth.js create mode 100644 lib/ClientSDK.js create mode 100644 lib/Config.js create mode 100644 lib/Controllers/AdaptableController.js create mode 100644 lib/Controllers/AnalyticsController.js create mode 100644 lib/Controllers/CacheController.js create mode 100644 lib/Controllers/DatabaseController.js create mode 100644 lib/Controllers/FilesController.js create mode 100644 lib/Controllers/HooksController.js create mode 100644 lib/Controllers/LiveQueryController.js create mode 100644 lib/Controllers/LoggerController.js create mode 100644 lib/Controllers/PushController.js create mode 100644 lib/Controllers/SchemaCache.js create mode 100644 lib/Controllers/SchemaController.js create mode 100644 lib/Controllers/UserController.js create mode 100644 lib/Controllers/index.js create mode 100644 lib/LiveQuery/Client.js create mode 100644 lib/LiveQuery/Id.js create mode 100644 lib/LiveQuery/ParseCloudCodePublisher.js create mode 100644 lib/LiveQuery/ParseLiveQueryServer.js create mode 100644 lib/LiveQuery/ParsePubSub.js create mode 100644 lib/LiveQuery/ParseWebSocketServer.js create mode 100644 lib/LiveQuery/QueryTools.js create mode 100644 lib/LiveQuery/RequestSchema.js create mode 100644 lib/LiveQuery/SessionTokenCache.js create mode 100644 lib/LiveQuery/Subscription.js create mode 100644 lib/LiveQuery/equalObjects.js create mode 100644 lib/Options/Definitions.js create mode 100644 lib/Options/index.js create mode 100644 lib/Options/parsers.js create mode 100644 lib/ParseMessageQueue.js create mode 100644 lib/ParseServer.js create mode 100644 lib/ParseServerRESTController.js create mode 100644 lib/PromiseRouter.js create mode 100644 lib/Push/PushQueue.js create mode 100644 lib/Push/PushWorker.js create mode 100644 lib/Push/utils.js create mode 100644 lib/RestQuery.js create mode 100644 lib/RestWrite.js create mode 100644 lib/Routers/AggregateRouter.js create mode 100644 lib/Routers/AnalyticsRouter.js create mode 100644 lib/Routers/AudiencesRouter.js create mode 100644 lib/Routers/ClassesRouter.js create mode 100644 lib/Routers/CloudCodeRouter.js create mode 100644 lib/Routers/ExportRouter.js create mode 100644 lib/Routers/FeaturesRouter.js create mode 100644 lib/Routers/FilesRouter.js create mode 100644 lib/Routers/FunctionsRouter.js create mode 100644 lib/Routers/GlobalConfigRouter.js create mode 100644 lib/Routers/HooksRouter.js create mode 100644 lib/Routers/IAPValidationRouter.js create mode 100644 lib/Routers/ImportRouter.js create mode 100644 lib/Routers/InstallationsRouter.js create mode 100644 lib/Routers/LogsRouter.js create mode 100644 lib/Routers/PublicAPIRouter.js create mode 100644 lib/Routers/PurgeRouter.js create mode 100644 lib/Routers/PushRouter.js create mode 100644 lib/Routers/RolesRouter.js create mode 100644 lib/Routers/SchemasRouter.js create mode 100644 lib/Routers/SessionsRouter.js create mode 100644 lib/Routers/UsersRouter.js create mode 100644 lib/StatusHandler.js create mode 100644 lib/TestUtils.js create mode 100644 lib/batch.js create mode 100644 lib/cache.js create mode 100644 lib/cli/definitions/parse-live-query-server.js create mode 100644 lib/cli/definitions/parse-server.js create mode 100644 lib/cli/parse-live-query-server.js create mode 100755 lib/cli/parse-server.js create mode 100644 lib/cli/utils/commander.js create mode 100644 lib/cli/utils/runner.js create mode 100644 lib/cloud-code/HTTPResponse.js create mode 100644 lib/cloud-code/Parse.Cloud.js create mode 100644 lib/cloud-code/httpRequest.js create mode 100644 lib/cryptoUtils.js create mode 100644 lib/defaults.js create mode 100644 lib/deprecated.js create mode 100644 lib/index.js create mode 100644 lib/logger.js create mode 100644 lib/middlewares.js create mode 100644 lib/password.js create mode 100644 lib/requiredParameter.js create mode 100644 lib/rest.js create mode 100644 lib/triggers.js create mode 100644 lib/vendor/README.md create mode 100644 lib/vendor/mongodbUrl.js create mode 100644 spec/Export.spec.js create mode 100644 spec/Import.spec.js create mode 100644 src/Routers/ExportRouter.js create mode 100644 src/Routers/ImportRouter.js diff --git a/.gitignore b/.gitignore index 4e4ee21cae..8f1edaabbf 100644 --- a/.gitignore +++ b/.gitignore @@ -41,7 +41,7 @@ node_modules .vscode # Babel.js -lib/ +#lib/ # cache folder .cache diff --git a/lib/AccountLockout.js b/lib/AccountLockout.js new file mode 100644 index 0000000000..dd1522e9c7 --- /dev/null +++ b/lib/AccountLockout.js @@ -0,0 +1,159 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AccountLockout = undefined; + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class AccountLockout { + constructor(user, config) { + this._user = user; + this._config = config; + } + + /** + * set _failed_login_count to value + */ + _setFailedLoginCount(value) { + const query = { + username: this._user.username + }; + + const updateFields = { + _failed_login_count: value + }; + + return this._config.database.update('_User', query, updateFields); + } + + /** + * check if the _failed_login_count field has been set + */ + _isFailedLoginCountSet() { + const query = { + username: this._user.username, + _failed_login_count: { $exists: true } + }; + + return this._config.database.find('_User', query).then(users => { + if (Array.isArray(users) && users.length > 0) { + return true; + } else { + return false; + } + }); + } + + /** + * if _failed_login_count is NOT set then set it to 0 + * else do nothing + */ + _initFailedLoginCount() { + return this._isFailedLoginCountSet().then(failedLoginCountIsSet => { + if (!failedLoginCountIsSet) { + return this._setFailedLoginCount(0); + } + }); + } + + /** + * increment _failed_login_count by 1 + */ + _incrementFailedLoginCount() { + const query = { + username: this._user.username + }; + + const 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 + */ + _setLockoutExpiration() { + const query = { + username: this._user.username, + _failed_login_count: { $gte: this._config.accountLockout.threshold } + }; + + const now = new Date(); + + const updateFields = { + _account_lockout_expires_at: _node2.default._encode(new Date(now.getTime() + this._config.accountLockout.duration * 60 * 1000)) + }; + + return this._config.database.update('_User', query, updateFields).catch(err => { + if (err && err.code && err.message && err.code === 101 && err.message === 'Object not found.') { + return; // nothing to update so we are good + } else { + throw err; // unknown error + } + }); + } + + /** + * if _account_lockout_expires_at > current_time and _failed_login_count > threshold + * reject with account locked error + * else + * resolve + */ + _notLocked() { + const query = { + username: this._user.username, + _account_lockout_expires_at: { $gt: _node2.default._encode(new Date()) }, + _failed_login_count: { $gte: this._config.accountLockout.threshold } + }; + + return this._config.database.find('_User', query).then(users => { + if (Array.isArray(users) && users.length > 0) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Your account is locked due to multiple failed login attempts. Please try again after ' + this._config.accountLockout.duration + ' minute(s)'); + } + }); + } + + /** + * 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 + */ + _handleFailedLoginAttempt() { + return this._initFailedLoginCount().then(() => { + return this._incrementFailedLoginCount(); + }).then(() => { + return this._setLockoutExpiration(); + }); + } + + /** + * handle login attempt if the Account Lockout Policy is enabled + */ + handleLoginAttempt(loginSuccessful) { + if (!this._config.accountLockout) { + return Promise.resolve(); + } + return this._notLocked().then(() => { + if (loginSuccessful) { + return this._setFailedLoginCount(0); + } else { + return this._handleFailedLoginAttempt(); + } + }); + } + +} + +exports.AccountLockout = AccountLockout; // This class handles the Account Lockout Policy settings. + +exports.default = AccountLockout; \ No newline at end of file diff --git a/lib/Adapters/AdapterLoader.js b/lib/Adapters/AdapterLoader.js new file mode 100644 index 0000000000..ffdf98fd95 --- /dev/null +++ b/lib/Adapters/AdapterLoader.js @@ -0,0 +1,44 @@ +"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") { + /* eslint-disable */ + 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; \ No newline at end of file diff --git a/lib/Adapters/Analytics/AnalyticsAdapter.js b/lib/Adapters/Analytics/AnalyticsAdapter.js new file mode 100644 index 0000000000..d4af892ac0 --- /dev/null +++ b/lib/Adapters/Analytics/AnalyticsAdapter.js @@ -0,0 +1,28 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/*eslint no-unused-vars: "off"*/ +class AnalyticsAdapter { + + /* + @param parameters: the analytics request body, analytics info will be in the dimensions property + @param req: the original http request + */ + appOpened(parameters, req) { + return Promise.resolve({}); + } + + /* + @param eventName: the name of the custom eventName + @param parameters: the analytics request body, analytics info will be in the dimensions property + @param req: the original http request + */ + trackEvent(eventName, parameters, req) { + return Promise.resolve({}); + } +} + +exports.AnalyticsAdapter = AnalyticsAdapter; +exports.default = AnalyticsAdapter; \ No newline at end of file diff --git a/lib/Adapters/Auth/AuthAdapter.js b/lib/Adapters/Auth/AuthAdapter.js new file mode 100644 index 0000000000..b3dec519db --- /dev/null +++ b/lib/Adapters/Auth/AuthAdapter.js @@ -0,0 +1,28 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/*eslint no-unused-vars: "off"*/ +class AuthAdapter { + + /* + @param appIds: the specified app ids in the configuration + @param authData: the client provided authData + @returns a promise that resolves if the applicationId is valid + */ + validateAppId(appIds, authData) { + return Promise.resolve({}); + } + + /* + @param authData: the client provided authData + @param options: additional options + */ + validateAuthData(authData, options) { + return Promise.resolve({}); + } +} + +exports.AuthAdapter = AuthAdapter; +exports.default = AuthAdapter; \ No newline at end of file diff --git a/lib/Adapters/Auth/OAuth1Client.js b/lib/Adapters/Auth/OAuth1Client.js new file mode 100644 index 0000000000..68da0c6f99 --- /dev/null +++ b/lib/Adapters/Auth/OAuth1Client.js @@ -0,0 +1,222 @@ +'use strict'; + +var https = require('https'), + crypto = require('crypto'); +var Parse = require('parse/node').Parse; + +var OAuth = function (options) { + if (!options) { + throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'No options passed to OAuth'); + } + this.consumer_key = options.consumer_key; + this.consumer_secret = options.consumer_secret; + this.auth_token = options.auth_token; + this.auth_token_secret = options.auth_token_secret; + this.host = options.host; + this.oauth_params = options.oauth_params || {}; +}; + +OAuth.prototype.send = function (method, path, params, body) { + + var request = this.buildRequest(method, path, params, body); + // Encode the body properly, the current Parse Implementation don't do it properly + return new Promise(function (resolve, reject) { + var httpRequest = https.request(request, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + data = JSON.parse(data); + resolve(data); + }); + }).on('error', function () { + reject('Failed to make an OAuth request'); + }); + if (request.body) { + httpRequest.write(request.body); + } + httpRequest.end(); + }); +}; + +OAuth.prototype.buildRequest = function (method, path, params, body) { + if (path.indexOf("/") != 0) { + path = "/" + path; + } + if (params && Object.keys(params).length > 0) { + path += "?" + OAuth.buildParameterString(params); + } + + var request = { + host: this.host, + path: path, + method: method.toUpperCase() + }; + + var oauth_params = this.oauth_params || {}; + oauth_params.oauth_consumer_key = this.consumer_key; + if (this.auth_token) { + oauth_params["oauth_token"] = this.auth_token; + } + + request = OAuth.signRequest(request, oauth_params, this.consumer_secret, this.auth_token_secret); + + if (body && Object.keys(body).length > 0) { + request.body = OAuth.buildParameterString(body); + } + return request; +}; + +OAuth.prototype.get = function (path, params) { + return this.send("GET", path, params); +}; + +OAuth.prototype.post = function (path, params, body) { + return this.send("POST", path, params, body); +}; + +/* + Proper string %escape encoding +*/ +OAuth.encode = function (str) { + // discuss at: http://phpjs.org/functions/rawurlencode/ + // original by: Brett Zamir (http://brett-zamir.me) + // input by: travc + // input by: Brett Zamir (http://brett-zamir.me) + // input by: Michael Grier + // input by: Ratheous + // bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net) + // bugfixed by: Brett Zamir (http://brett-zamir.me) + // bugfixed by: Joris + // reimplemented by: Brett Zamir (http://brett-zamir.me) + // reimplemented by: Brett Zamir (http://brett-zamir.me) + // note: This reflects PHP 5.3/6.0+ behavior + // note: Please be aware that this function expects to encode into UTF-8 encoded strings, as found on + // note: pages served as UTF-8 + // example 1: rawurlencode('Kevin van Zonneveld!'); + // returns 1: 'Kevin%20van%20Zonneveld%21' + // example 2: rawurlencode('http://kevin.vanzonneveld.net/'); + // returns 2: 'http%3A%2F%2Fkevin.vanzonneveld.net%2F' + // example 3: rawurlencode('http://www.google.nl/search?q=php.js&ie=utf-8&oe=utf-8&aq=t&rls=com.ubuntu:en-US:unofficial&client=firefox-a'); + // returns 3: 'http%3A%2F%2Fwww.google.nl%2Fsearch%3Fq%3Dphp.js%26ie%3Dutf-8%26oe%3Dutf-8%26aq%3Dt%26rls%3Dcom.ubuntu%3Aen-US%3Aunofficial%26client%3Dfirefox-a' + + str = (str + '').toString(); + + // Tilde should be allowed unescaped in future versions of PHP (as reflected below), but if you want to reflect current + // PHP behavior, you would need to add ".replace(/~/g, '%7E');" to the following. + return encodeURIComponent(str).replace(/!/g, '%21').replace(/'/g, '%27').replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/\*/g, '%2A'); +}; + +OAuth.signatureMethod = "HMAC-SHA1"; +OAuth.version = "1.0"; + +/* + Generate a nonce +*/ +OAuth.nonce = function () { + var text = ""; + var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; + + for (var i = 0; i < 30; i++) text += possible.charAt(Math.floor(Math.random() * possible.length)); + + return text; +}; + +OAuth.buildParameterString = function (obj) { + // Sort keys and encode values + if (obj) { + var keys = Object.keys(obj).sort(); + + // Map key=value, join them by & + return keys.map(function (key) { + return key + "=" + OAuth.encode(obj[key]); + }).join("&"); + } + + return ""; +}; + +/* + Build the signature string from the object +*/ + +OAuth.buildSignatureString = function (method, url, parameters) { + return [method.toUpperCase(), OAuth.encode(url), OAuth.encode(parameters)].join("&"); +}; + +/* + Retuns encoded HMAC-SHA1 from key and text +*/ +OAuth.signature = function (text, key) { + crypto = require("crypto"); + return OAuth.encode(crypto.createHmac('sha1', key).update(text).digest('base64')); +}; + +OAuth.signRequest = function (request, oauth_parameters, consumer_secret, auth_token_secret) { + oauth_parameters = oauth_parameters || {}; + + // Set default values + if (!oauth_parameters.oauth_nonce) { + oauth_parameters.oauth_nonce = OAuth.nonce(); + } + if (!oauth_parameters.oauth_timestamp) { + oauth_parameters.oauth_timestamp = Math.floor(new Date().getTime() / 1000); + } + if (!oauth_parameters.oauth_signature_method) { + oauth_parameters.oauth_signature_method = OAuth.signatureMethod; + } + if (!oauth_parameters.oauth_version) { + oauth_parameters.oauth_version = OAuth.version; + } + + if (!auth_token_secret) { + auth_token_secret = ""; + } + // Force GET method if unset + if (!request.method) { + request.method = "GET"; + } + + // Collect all the parameters in one signatureParameters object + var signatureParams = {}; + var parametersToMerge = [request.params, request.body, oauth_parameters]; + for (var i in parametersToMerge) { + var parameters = parametersToMerge[i]; + for (var k in parameters) { + signatureParams[k] = parameters[k]; + } + } + + // Create a string based on the parameters + var parameterString = OAuth.buildParameterString(signatureParams); + + // Build the signature string + var url = "https://" + request.host + "" + request.path; + + var signatureString = OAuth.buildSignatureString(request.method, url, parameterString); + // Hash the signature string + var signatureKey = [OAuth.encode(consumer_secret), OAuth.encode(auth_token_secret)].join("&"); + + var signature = OAuth.signature(signatureString, signatureKey); + + // Set the signature in the params + oauth_parameters.oauth_signature = signature; + if (!request.headers) { + request.headers = {}; + } + + // Set the authorization header + var authHeader = Object.keys(oauth_parameters).sort().map(function (key) { + var value = oauth_parameters[key]; + return key + '="' + value + '"'; + }).join(", "); + + request.headers.Authorization = 'OAuth ' + authHeader; + + // Set the content type header + request.headers["Content-Type"] = "application/x-www-form-urlencoded"; + return request; +}; + +module.exports = OAuth; \ No newline at end of file diff --git a/lib/Adapters/Auth/facebook.js b/lib/Adapters/Auth/facebook.js new file mode 100644 index 0000000000..2e422926f8 --- /dev/null +++ b/lib/Adapters/Auth/facebook.js @@ -0,0 +1,56 @@ +'use strict'; + +// Helper functions for accessing the Facebook Graph API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return graphRequest('me?fields=id&access_token=' + authData.access_token).then(data => { + if (data && data.id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId(appIds, authData) { + var access_token = authData.access_token; + if (!appIds.length) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is not configured.'); + } + return graphRequest('app?access_token=' + access_token).then(data => { + if (data && appIds.indexOf(data.id) != -1) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is invalid for this user.'); + }); +} + +// A promisey wrapper for FB graph requests. +function graphRequest(path) { + return new Promise(function (resolve, reject) { + https.get('https://graph.facebook.com/v2.5/' + path, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Facebook.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/github.js b/lib/Adapters/Auth/github.js new file mode 100644 index 0000000000..e727313fc7 --- /dev/null +++ b/lib/Adapters/Auth/github.js @@ -0,0 +1,54 @@ +'use strict'; + +// Helper functions for accessing the github API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return request('user', authData.access_token).then(data => { + if (data && data.id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Github auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(path, access_token) { + return new Promise(function (resolve, reject) { + https.get({ + host: 'api.github.com', + path: '/' + path, + headers: { + 'Authorization': 'bearer ' + access_token, + 'User-Agent': 'parse-server' + } + }, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Github.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/google.js b/lib/Adapters/Auth/google.js new file mode 100644 index 0000000000..898eeeffdb --- /dev/null +++ b/lib/Adapters/Auth/google.js @@ -0,0 +1,70 @@ +'use strict'; + +// Helper functions for accessing the google API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +function validateIdToken(id, token) { + return request("tokeninfo?id_token=" + token).then(response => { + if (response && (response.sub == id || response.user_id == id)) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Google auth is invalid for this user.'); + }); +} + +function validateAuthToken(id, token) { + return request("tokeninfo?access_token=" + token).then(response => { + if (response && (response.sub == id || response.user_id == id)) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Google auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills if this user id is valid. +function validateAuthData(authData) { + if (authData.id_token) { + return validateIdToken(authData.id, authData.id_token); + } else { + return validateAuthToken(authData.id, authData.access_token).then(() => { + // Validation with auth token worked + return; + }, () => { + // Try with the id_token param + return validateIdToken(authData.id, authData.access_token); + }); + } +} + +// Returns a promise that fulfills if this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(path) { + return new Promise(function (resolve, reject) { + https.get("https://www.googleapis.com/oauth2/v3/" + path, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Google.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/index.js b/lib/Adapters/Auth/index.js new file mode 100755 index 0000000000..1fd4073170 --- /dev/null +++ b/lib/Adapters/Auth/index.js @@ -0,0 +1,121 @@ +'use strict'; + +var _AdapterLoader = require('../AdapterLoader'); + +var _AdapterLoader2 = _interopRequireDefault(_AdapterLoader); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const facebook = require('./facebook'); +const instagram = require("./instagram"); +const linkedin = require("./linkedin"); +const meetup = require("./meetup"); +const google = require("./google"); +const github = require("./github"); +const twitter = require("./twitter"); +const spotify = require("./spotify"); +const digits = require("./twitter"); // digits tokens are validated by twitter +const janrainengage = require("./janrainengage"); +const janraincapture = require("./janraincapture"); +const vkontakte = require("./vkontakte"); +const qq = require("./qq"); +const wechat = require("./wechat"); +const weibo = require("./weibo"); + +const anonymous = { + validateAuthData: () => { + return Promise.resolve(); + }, + validateAppId: () => { + return Promise.resolve(); + } +}; + +const providers = { + facebook, + instagram, + linkedin, + meetup, + google, + github, + twitter, + spotify, + anonymous, + digits, + janrainengage, + janraincapture, + vkontakte, + qq, + wechat, + weibo +}; + +function authDataValidator(adapter, appIds, options) { + return function (authData) { + return adapter.validateAuthData(authData, options).then(() => { + if (appIds) { + return adapter.validateAppId(appIds, authData, options); + } + return Promise.resolve(); + }); + }; +} + +function loadAuthAdapter(provider, authOptions) { + const defaultAdapter = providers[provider]; + const adapter = Object.assign({}, defaultAdapter); + const providerOptions = authOptions[provider]; + + if (!defaultAdapter && !providerOptions) { + return; + } + + const appIds = providerOptions ? providerOptions.appIds : undefined; + + // Try the configuration methods + if (providerOptions) { + const optionalAdapter = (0, _AdapterLoader2.default)(providerOptions, undefined, providerOptions); + if (optionalAdapter) { + ['validateAuthData', 'validateAppId'].forEach(key => { + if (optionalAdapter[key]) { + adapter[key] = optionalAdapter[key]; + } + }); + } + } + + if (!adapter.validateAuthData || !adapter.validateAppId) { + return; + } + + return { adapter, appIds, providerOptions }; +} + +module.exports = function (authOptions = {}, enableAnonymousUsers = true) { + let _enableAnonymousUsers = enableAnonymousUsers; + const setEnableAnonymousUsers = function (enable) { + _enableAnonymousUsers = enable; + }; + // To handle the test cases on configuration + const getValidatorForProvider = function (provider) { + + if (provider === 'anonymous' && !_enableAnonymousUsers) { + return; + } + + const { + adapter, + appIds, + providerOptions + } = loadAuthAdapter(provider, authOptions); + + return authDataValidator(adapter, appIds, providerOptions); + }; + + return Object.freeze({ + getValidatorForProvider, + setEnableAnonymousUsers + }); +}; + +module.exports.loadAuthAdapter = loadAuthAdapter; \ No newline at end of file diff --git a/lib/Adapters/Auth/instagram.js b/lib/Adapters/Auth/instagram.js new file mode 100644 index 0000000000..090bc168d9 --- /dev/null +++ b/lib/Adapters/Auth/instagram.js @@ -0,0 +1,43 @@ +'use strict'; + +// Helper functions for accessing the instagram API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return request("users/self/?access_token=" + authData.access_token).then(response => { + if (response && response.data && response.data.id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(path) { + return new Promise(function (resolve, reject) { + https.get("https://api.instagram.com/v1/" + path, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + data = JSON.parse(data); + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Instagram.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/janraincapture.js b/lib/Adapters/Auth/janraincapture.js new file mode 100644 index 0000000000..bfab1a995c --- /dev/null +++ b/lib/Adapters/Auth/janraincapture.js @@ -0,0 +1,55 @@ +'use strict'; + +// Helper functions for accessing the Janrain Capture API. +var https = require('https'); +var Parse = require('parse/node').Parse; +var querystring = require('querystring'); + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData, options) { + return request(options.janrain_capture_host, authData.access_token).then(data => { + //successful response will have a "stat" (status) of 'ok' and a result node that stores the uuid, because that's all we asked for + //see: https://docs.janrain.com/api/registration/entity/#entity + if (data && data.stat == 'ok' && data.result == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Janrain capture auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + //no-op + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(host, access_token) { + + var query_string_data = querystring.stringify({ + 'access_token': access_token, + 'attribute_name': 'uuid' // we only need to pull the uuid for this access token to make sure it matches + }); + + return new Promise(function (resolve, reject) { + https.get({ + host: host, + path: '/entity?' + query_string_data + }, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + resolve(JSON.parse(data)); + }); + }).on('error', function () { + reject('Failed to validate this access token with Janrain capture.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/janrainengage.js b/lib/Adapters/Auth/janrainengage.js new file mode 100644 index 0000000000..c3936dfd63 --- /dev/null +++ b/lib/Adapters/Auth/janrainengage.js @@ -0,0 +1,73 @@ +'use strict'; + +// Helper functions for accessing the Janrain Engage API. +var https = require('https'); +var Parse = require('parse/node').Parse; +var querystring = require('querystring'); + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData, options) { + return request(options.api_key, authData.auth_token).then(data => { + //successful response will have a "stat" (status) of 'ok' and a profile node with an identifier + //see: http://developers.janrain.com/overview/social-login/identity-providers/user-profile-data/#normalized-user-profile-data + if (data && data.stat == 'ok' && data.profile.identifier == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Janrain engage auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + //no-op + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(api_key, auth_token) { + + var post_data = querystring.stringify({ + 'token': auth_token, + 'apiKey': api_key, + 'format': 'json' + }); + + var post_options = { + host: 'rpxnow.com', + path: '/api/v2/auth_info', + method: 'POST', + headers: { + 'Content-Type': 'application/x-www-form-urlencoded', + 'Content-Length': post_data.length + } + }; + + return new Promise(function (resolve, reject) { + // Create the post request. + var post_req = https.request(post_options, function (res) { + var data = ''; + res.setEncoding('utf8'); + // Append data as we receive it from the Janrain engage server. + res.on('data', function (d) { + data += d; + }); + // Once we have all the data, we can parse it and return the data we want. + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }); + + post_req.write(post_data); + post_req.end(); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/linkedin.js b/lib/Adapters/Auth/linkedin.js new file mode 100644 index 0000000000..702de7081b --- /dev/null +++ b/lib/Adapters/Auth/linkedin.js @@ -0,0 +1,60 @@ +'use strict'; + +// Helper functions for accessing the linkedin API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return request('people/~:(id)', authData.access_token, authData.is_mobile_sdk).then(data => { + if (data && data.id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Linkedin auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(path, access_token, is_mobile_sdk) { + var headers = { + 'Authorization': 'Bearer ' + access_token, + 'x-li-format': 'json' + }; + + if (is_mobile_sdk) { + headers['x-li-src'] = 'msdk'; + } + + return new Promise(function (resolve, reject) { + https.get({ + host: 'api.linkedin.com', + path: '/v1/' + path, + headers: headers + }, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Linkedin.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/meetup.js b/lib/Adapters/Auth/meetup.js new file mode 100644 index 0000000000..7a996510b5 --- /dev/null +++ b/lib/Adapters/Auth/meetup.js @@ -0,0 +1,53 @@ +'use strict'; + +// Helper functions for accessing the meetup API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return request('member/self', authData.access_token).then(data => { + if (data && data.id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Meetup auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(path, access_token) { + return new Promise(function (resolve, reject) { + https.get({ + host: 'api.meetup.com', + path: '/2/' + path, + headers: { + 'Authorization': 'bearer ' + access_token + } + }, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Meetup.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/qq.js b/lib/Adapters/Auth/qq.js new file mode 100644 index 0000000000..aa82ca6b62 --- /dev/null +++ b/lib/Adapters/Auth/qq.js @@ -0,0 +1,53 @@ +'use strict'; + +// Helper functions for accessing the qq Graph API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return graphRequest('me?access_token=' + authData.access_token).then(function (data) { + if (data && data.openid == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills if this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for qq graph requests. +function graphRequest(path) { + return new Promise(function (resolve, reject) { + https.get('https://graph.qq.com/oauth2.0/' + path, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + var starPos = data.indexOf("("); + var endPos = data.indexOf(")"); + if (starPos == -1 || endPos == -1) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq auth is invalid for this user.'); + } + data = data.substring(starPos + 1, endPos - 1); + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with qq.'); + }); + }); +} + +module.exports = { + validateAppId, + validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/spotify.js b/lib/Adapters/Auth/spotify.js new file mode 100644 index 0000000000..f1d8f6da21 --- /dev/null +++ b/lib/Adapters/Auth/spotify.js @@ -0,0 +1,62 @@ +'use strict'; + +// Helper functions for accessing the Spotify API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return request('me', authData.access_token).then(data => { + if (data && data.id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills if this app id is valid. +function validateAppId(appIds, authData) { + var access_token = authData.access_token; + if (!appIds.length) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is not configured.'); + } + return request('me', access_token).then(data => { + if (data && appIds.indexOf(data.id) != -1) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is invalid for this user.'); + }); +} + +// A promisey wrapper for Spotify API requests. +function request(path, access_token) { + return new Promise(function (resolve, reject) { + https.get({ + host: 'api.spotify.com', + path: '/v1/' + path, + headers: { + 'Authorization': 'Bearer ' + access_token + } + }, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Spotify.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/twitter.js b/lib/Adapters/Auth/twitter.js new file mode 100644 index 0000000000..4f4560fedc --- /dev/null +++ b/lib/Adapters/Auth/twitter.js @@ -0,0 +1,56 @@ +'use strict'; + +// Helper functions for accessing the twitter API. +var OAuth = require('./OAuth1Client'); +var Parse = require('parse/node').Parse; +var logger = require('../../logger').default; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData, options) { + if (!options) { + throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Twitter auth configuration missing'); + } + options = handleMultipleConfigurations(authData, options); + var client = new OAuth(options); + client.host = "api.twitter.com"; + client.auth_token = authData.auth_token; + client.auth_token_secret = authData.auth_token_secret; + + return client.get("/1.1/account/verify_credentials.json").then(data => { + if (data && data.id_str == '' + authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +function handleMultipleConfigurations(authData, options) { + if (Array.isArray(options)) { + const consumer_key = authData.consumer_key; + if (!consumer_key) { + logger.error('Twitter Auth', 'Multiple twitter configurations are available, by no consumer_key was sent by the client.'); + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.'); + } + options = options.filter(option => { + return option.consumer_key == consumer_key; + }); + + if (options.length == 0) { + logger.error('Twitter Auth', 'Cannot find a configuration for the provided consumer_key'); + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.'); + } + options = options[0]; + } + return options; +} + +module.exports = { + validateAppId, + validateAuthData, + handleMultipleConfigurations +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/vkontakte.js b/lib/Adapters/Auth/vkontakte.js new file mode 100644 index 0000000000..195a33f93b --- /dev/null +++ b/lib/Adapters/Auth/vkontakte.js @@ -0,0 +1,67 @@ +'use strict'; + +// Helper functions for accessing the vkontakte API. + +var https = require('https'); +var Parse = require('parse/node').Parse; +var logger = require('../../logger').default; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData, params) { + return vkOAuth2Request(params).then(function (response) { + if (response && response.access_token) { + return request("api.vk.com", "method/secure.checkToken?token=" + authData.access_token + "&client_secret=" + params.appSecret + "&access_token=" + response.access_token).then(function (response) { + if (response && response.response && response.response.user_id == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is invalid for this user.'); + }); + } + logger.error('Vk Auth', 'Vk appIds or appSecret is incorrect.'); + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk appIds or appSecret is incorrect.'); + }); +} + +function vkOAuth2Request(params) { + return new Promise(function (resolve) { + if (!params || !params.appIds || !params.appIds.length || !params.appSecret || !params.appSecret.length) { + logger.error('Vk Auth', 'Vk auth is not configured. Missing appIds or appSecret.'); + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is not configured. Missing appIds or appSecret.'); + } + resolve(); + }).then(function () { + return request("oauth.vk.com", "access_token?client_id=" + params.appIds + "&client_secret=" + params.appSecret + "&v=5.59&grant_type=client_credentials"); + }); +} + +// Returns a promise that fulfills iff this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for api requests +function request(host, path) { + return new Promise(function (resolve, reject) { + https.get("https://" + host + "/" + path, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with Vk.'); + }); + }); +} + +module.exports = { + validateAppId: validateAppId, + validateAuthData: validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/wechat.js b/lib/Adapters/Auth/wechat.js new file mode 100644 index 0000000000..1f0aebaa50 --- /dev/null +++ b/lib/Adapters/Auth/wechat.js @@ -0,0 +1,47 @@ +'use strict'; + +// Helper functions for accessing the WeChat Graph API. +var https = require('https'); +var Parse = require('parse/node').Parse; + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return graphRequest('auth?access_token=' + authData.access_token + '&openid=' + authData.id).then(function (data) { + if (data.errcode == 0) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'wechat auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills if this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for WeChat graph requests. +function graphRequest(path) { + return new Promise(function (resolve, reject) { + https.get('https://api.weixin.qq.com/sns/' + path, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + }).on('error', function () { + reject('Failed to validate this access token with wechat.'); + }); + }); +} + +module.exports = { + validateAppId, + validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Auth/weibo.js b/lib/Adapters/Auth/weibo.js new file mode 100644 index 0000000000..b6a0d0f46d --- /dev/null +++ b/lib/Adapters/Auth/weibo.js @@ -0,0 +1,66 @@ +'use strict'; + +// Helper functions for accessing the weibo Graph API. +var https = require('https'); +var Parse = require('parse/node').Parse; +var querystring = require('querystring'); + +// Returns a promise that fulfills iff this user id is valid. +function validateAuthData(authData) { + return graphRequest(authData.access_token).then(function (data) { + if (data && data.uid == authData.id) { + return; + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'weibo auth is invalid for this user.'); + }); +} + +// Returns a promise that fulfills if this app id is valid. +function validateAppId() { + return Promise.resolve(); +} + +// A promisey wrapper for weibo graph requests. +function graphRequest(access_token) { + return new Promise(function (resolve, reject) { + var postData = querystring.stringify({ + "access_token": access_token + }); + var options = { + hostname: 'api.weibo.com', + path: '/oauth2/get_token_info', + method: 'POST', + headers: { + 'Content-Type': 'application/x-www-form-urlencoded', + 'Content-Length': Buffer.byteLength(postData) + } + }; + var req = https.request(options, function (res) { + var data = ''; + res.on('data', function (chunk) { + data += chunk; + }); + res.on('end', function () { + try { + data = JSON.parse(data); + } catch (e) { + return reject(e); + } + resolve(data); + }); + res.on('error', function () { + reject('Failed to validate this access token with weibo.'); + }); + }); + req.on('error', function () { + reject('Failed to validate this access token with weibo.'); + }); + req.write(postData); + req.end(); + }); +} + +module.exports = { + validateAppId, + validateAuthData +}; \ No newline at end of file diff --git a/lib/Adapters/Cache/CacheAdapter.js b/lib/Adapters/Cache/CacheAdapter.js new file mode 100644 index 0000000000..bbb17ef749 --- /dev/null +++ b/lib/Adapters/Cache/CacheAdapter.js @@ -0,0 +1,34 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/*eslint no-unused-vars: "off"*/ +class CacheAdapter { + /** + * Get a value in the cache + * @param key Cache key to get + * @return Promise that will eventually resolve to the value in the cache. + */ + get(key) {} + + /** + * Set a value in the cache + * @param key Cache key to set + * @param value Value to set the key + * @param ttl Optional TTL + */ + put(key, value, ttl) {} + + /** + * Remove a value from the cache. + * @param key Cache key to remove + */ + del(key) {} + + /** + * Empty a cache + */ + clear() {} +} +exports.CacheAdapter = CacheAdapter; \ No newline at end of file diff --git a/lib/Adapters/Cache/InMemoryCache.js b/lib/Adapters/Cache/InMemoryCache.js new file mode 100644 index 0000000000..c76bbc729d --- /dev/null +++ b/lib/Adapters/Cache/InMemoryCache.js @@ -0,0 +1,70 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +const DEFAULT_CACHE_TTL = 5 * 1000; + +class InMemoryCache { + constructor({ + ttl = DEFAULT_CACHE_TTL + }) { + this.ttl = ttl; + this.cache = Object.create(null); + } + + get(key) { + const record = this.cache[key]; + if (record == null) { + return null; + } + + // Has Record and isnt expired + if (isNaN(record.expire) || record.expire >= Date.now()) { + return record.value; + } + + // Record has expired + delete this.cache[key]; + return null; + } + + put(key, value, ttl = this.ttl) { + if (ttl < 0 || isNaN(ttl)) { + ttl = NaN; + } + + var record = { + value: value, + expire: ttl + Date.now() + }; + + if (!isNaN(record.expire)) { + record.timeout = setTimeout(() => { + this.del(key); + }, ttl); + } + + this.cache[key] = record; + } + + del(key) { + var record = this.cache[key]; + if (record == null) { + return; + } + + if (record.timeout) { + clearTimeout(record.timeout); + } + delete this.cache[key]; + } + + clear() { + this.cache = Object.create(null); + } + +} + +exports.InMemoryCache = InMemoryCache; +exports.default = InMemoryCache; \ No newline at end of file diff --git a/lib/Adapters/Cache/InMemoryCacheAdapter.js b/lib/Adapters/Cache/InMemoryCacheAdapter.js new file mode 100644 index 0000000000..e3705c920c --- /dev/null +++ b/lib/Adapters/Cache/InMemoryCacheAdapter.js @@ -0,0 +1,41 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.InMemoryCacheAdapter = undefined; + +var _LRUCache = require('./LRUCache'); + +class InMemoryCacheAdapter { + + constructor(ctx) { + this.cache = new _LRUCache.LRUCache(ctx); + } + + get(key) { + const record = this.cache.get(key); + if (record === null) { + return Promise.resolve(null); + } + return Promise.resolve(record); + } + + put(key, value, ttl) { + this.cache.put(key, value, ttl); + return Promise.resolve(); + } + + del(key) { + this.cache.del(key); + return Promise.resolve(); + } + + clear() { + this.cache.clear(); + return Promise.resolve(); + } +} + +exports.InMemoryCacheAdapter = InMemoryCacheAdapter; +exports.default = InMemoryCacheAdapter; \ No newline at end of file diff --git a/lib/Adapters/Cache/LRUCache.js b/lib/Adapters/Cache/LRUCache.js new file mode 100644 index 0000000000..a4476aa154 --- /dev/null +++ b/lib/Adapters/Cache/LRUCache.js @@ -0,0 +1,48 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.LRUCache = undefined; + +var _lruCache = require('lru-cache'); + +var _lruCache2 = _interopRequireDefault(_lruCache); + +var _defaults = require('../../defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class LRUCache { + constructor({ + ttl = _defaults2.default.cacheTTL, + maxSize = _defaults2.default.cacheMaxSize + }) { + this.cache = new _lruCache2.default({ + max: maxSize, + maxAge: ttl + }); + } + + get(key) { + return this.cache.get(key) || null; + } + + put(key, value, ttl = this.ttl) { + this.cache.set(key, value, ttl); + } + + del(key) { + this.cache.del(key); + } + + clear() { + this.cache.reset(); + } + +} + +exports.LRUCache = LRUCache; +exports.default = LRUCache; \ No newline at end of file diff --git a/lib/Adapters/Cache/NullCacheAdapter.js b/lib/Adapters/Cache/NullCacheAdapter.js new file mode 100644 index 0000000000..55d536878c --- /dev/null +++ b/lib/Adapters/Cache/NullCacheAdapter.js @@ -0,0 +1,30 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +class NullCacheAdapter { + + constructor() {} + + get() { + return new Promise(resolve => { + return resolve(null); + }); + } + + put() { + return Promise.resolve(); + } + + del() { + return Promise.resolve(); + } + + clear() { + return Promise.resolve(); + } +} + +exports.NullCacheAdapter = NullCacheAdapter; +exports.default = NullCacheAdapter; \ No newline at end of file diff --git a/lib/Adapters/Cache/RedisCacheAdapter.js b/lib/Adapters/Cache/RedisCacheAdapter.js new file mode 100644 index 0000000000..615a4c8250 --- /dev/null +++ b/lib/Adapters/Cache/RedisCacheAdapter.js @@ -0,0 +1,99 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.RedisCacheAdapter = undefined; + +var _redis = require('redis'); + +var _redis2 = _interopRequireDefault(_redis); + +var _logger = require('../../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const DEFAULT_REDIS_TTL = 30 * 1000; // 30 seconds in milliseconds + +function debug() { + _logger2.default.debug.apply(_logger2.default, ['RedisCacheAdapter', ...arguments]); +} + +class RedisCacheAdapter { + + constructor(redisCtx, ttl = DEFAULT_REDIS_TTL) { + this.client = _redis2.default.createClient(redisCtx); + this.p = Promise.resolve(); + this.ttl = ttl; + } + + get(key) { + debug('get', key); + this.p = this.p.then(() => { + return new Promise(resolve => { + this.client.get(key, function (err, res) { + debug('-> get', key, res); + if (!res) { + return resolve(null); + } + resolve(JSON.parse(res)); + }); + }); + }); + return this.p; + } + + put(key, value, ttl = this.ttl) { + value = JSON.stringify(value); + debug('put', key, value, ttl); + if (ttl === 0) { + return this.p; // ttl of zero is a logical no-op, but redis cannot set expire time of zero + } + if (ttl < 0 || isNaN(ttl)) { + ttl = DEFAULT_REDIS_TTL; + } + this.p = this.p.then(() => { + return new Promise(resolve => { + if (ttl === Infinity) { + this.client.set(key, value, function () { + resolve(); + }); + } else { + this.client.psetex(key, ttl, value, function () { + resolve(); + }); + } + }); + }); + return this.p; + } + + del(key) { + debug('del', key); + this.p = this.p.then(() => { + return new Promise(resolve => { + this.client.del(key, function () { + resolve(); + }); + }); + }); + return this.p; + } + + clear() { + debug('clear'); + this.p = this.p.then(() => { + return new Promise(resolve => { + this.client.flushdb(function () { + resolve(); + }); + }); + }); + return this.p; + } +} + +exports.RedisCacheAdapter = RedisCacheAdapter; +exports.default = RedisCacheAdapter; \ No newline at end of file diff --git a/lib/Adapters/Email/MailAdapter.js b/lib/Adapters/Email/MailAdapter.js new file mode 100644 index 0000000000..b2fe018c92 --- /dev/null +++ b/lib/Adapters/Email/MailAdapter.js @@ -0,0 +1,29 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/*eslint no-unused-vars: "off"*/ +/* + Mail Adapter prototype + A MailAdapter should implement at least sendMail() + */ +class MailAdapter { + /* + * A method for sending mail + * @param options would have the parameters + * - to: the recipient + * - text: the raw text of the message + * - subject: the subject of the email + */ + sendMail(options) {} + + /* You can implement those methods if you want + * to provide HTML templates etc... + */ + // sendVerificationEmail({ link, appName, user }) {} + // sendPasswordResetEmail({ link, appName, user }) {} +} + +exports.MailAdapter = MailAdapter; +exports.default = MailAdapter; \ No newline at end of file diff --git a/lib/Adapters/Files/FilesAdapter.js b/lib/Adapters/Files/FilesAdapter.js new file mode 100644 index 0000000000..128cb2cd94 --- /dev/null +++ b/lib/Adapters/Files/FilesAdapter.js @@ -0,0 +1,60 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +class FilesAdapter { + + /* Responsible for storing the file in order to be retrieved later by its filename + * + * @param {string} filename - the filename to save + * @param {*} data - the buffer of data from the file + * @param {string} contentType - the supposed contentType + * @discussion the contentType can be undefined if the controller was not able to determine it + * + * @return {Promise} a promise that should fail if the storage didn't succeed + */ + createFile(filename, data, contentType) {} + + /* Responsible for deleting the specified file + * + * @param {string} filename - the filename to delete + * + * @return {Promise} a promise that should fail if the deletion didn't succeed + */ + deleteFile(filename) {} + + /* Responsible for retrieving the data of the specified file + * + * @param {string} filename - the name of file to retrieve + * + * @return {Promise} a promise that should pass with the file data or fail on error + */ + getFileData(filename) {} + + /* Returns an absolute URL where the file can be accessed + * + * @param {Config} config - server configuration + * @param {string} filename + * + * @return {string} Absolute URL + */ + getFileLocation(config, filename) {} +} + +exports.FilesAdapter = FilesAdapter; /*eslint no-unused-vars: "off"*/ +// Files Adapter +// +// Allows you to change the file storage mechanism. +// +// Adapter classes must implement the following functions: +// * createFile(filename, data, contentType) +// * deleteFile(filename) +// * getFileData(filename) +// * getFileLocation(config, filename) +// +// Default is GridStoreAdapter, which requires mongo +// and for the API server to be using the DatabaseController with Mongo +// database adapter. + +exports.default = FilesAdapter; \ No newline at end of file diff --git a/lib/Adapters/Files/GridStoreAdapter.js b/lib/Adapters/Files/GridStoreAdapter.js new file mode 100644 index 0000000000..d5e944344f --- /dev/null +++ b/lib/Adapters/Files/GridStoreAdapter.js @@ -0,0 +1,89 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.GridStoreAdapter = undefined; + +var _mongodb = require('mongodb'); + +var _FilesAdapter = require('./FilesAdapter'); + +var _defaults = require('../../defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class GridStoreAdapter extends _FilesAdapter.FilesAdapter { + + constructor(mongoDatabaseURI = _defaults2.default.DefaultMongoURI) { + super(); + this._databaseURI = mongoDatabaseURI; + } + + _connect() { + if (!this._connectionPromise) { + this._connectionPromise = _mongodb.MongoClient.connect(this._databaseURI); + } + return this._connectionPromise; + } + + // For a given config object, filename, and data, store a file + // Returns a promise + createFile(filename, data) { + return this._connect().then(database => { + const gridStore = new _mongodb.GridStore(database, filename, 'w'); + return gridStore.open(); + }).then(gridStore => { + return gridStore.write(data); + }).then(gridStore => { + return gridStore.close(); + }); + } + + deleteFile(filename) { + return this._connect().then(database => { + const gridStore = new _mongodb.GridStore(database, filename, 'r'); + return gridStore.open(); + }).then(gridStore => { + return gridStore.unlink(); + }).then(gridStore => { + return gridStore.close(); + }); + } + + getFileData(filename) { + return this._connect().then(database => { + return _mongodb.GridStore.exist(database, filename).then(() => { + const gridStore = new _mongodb.GridStore(database, filename, 'r'); + return gridStore.open(); + }); + }).then(gridStore => { + return gridStore.read(); + }); + } + + getFileLocation(config, filename) { + return config.mount + '/files/' + config.applicationId + '/' + encodeURIComponent(filename); + } + + getFileStream(filename) { + return this._connect().then(database => { + return _mongodb.GridStore.exist(database, filename).then(() => { + const gridStore = new _mongodb.GridStore(database, filename, 'r'); + return gridStore.open(); + }); + }); + } +} + +exports.GridStoreAdapter = GridStoreAdapter; /** + GridStoreAdapter + Stores files in Mongo using GridStore + Requires the database adapter to be based on mongoclient + + weak + */ + +exports.default = GridStoreAdapter; \ No newline at end of file diff --git a/lib/Adapters/Logger/LoggerAdapter.js b/lib/Adapters/Logger/LoggerAdapter.js new file mode 100644 index 0000000000..097955b9d4 --- /dev/null +++ b/lib/Adapters/Logger/LoggerAdapter.js @@ -0,0 +1,22 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/*eslint no-unused-vars: "off"*/ +// Logger Adapter +// +// Allows you to change the logger mechanism +// +// Adapter classes must implement the following functions: +// * log() {} +// * query(options, callback) /* optional */ +// Default is WinstonLoggerAdapter.js + +class LoggerAdapter { + constructor(options) {} + log(level, message) /* meta */{} +} + +exports.LoggerAdapter = LoggerAdapter; +exports.default = LoggerAdapter; \ No newline at end of file diff --git a/lib/Adapters/Logger/WinstonLogger.js b/lib/Adapters/Logger/WinstonLogger.js new file mode 100644 index 0000000000..bda6f18ea8 --- /dev/null +++ b/lib/Adapters/Logger/WinstonLogger.js @@ -0,0 +1,125 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.logger = undefined; +exports.configureLogger = configureLogger; +exports.addTransport = addTransport; +exports.removeTransport = removeTransport; + +var _winston = require('winston'); + +var _winston2 = _interopRequireDefault(_winston); + +var _fs = require('fs'); + +var _fs2 = _interopRequireDefault(_fs); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _winstonDailyRotateFile = require('winston-daily-rotate-file'); + +var _winstonDailyRotateFile2 = _interopRequireDefault(_winstonDailyRotateFile); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _defaults = require('../../defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const logger = new _winston2.default.Logger(); +const additionalTransports = []; + +function updateTransports(options) { + const transports = Object.assign({}, logger.transports); + if (options) { + const silent = options.silent; + delete options.silent; + if (_lodash2.default.isNull(options.dirname)) { + delete transports['parse-server']; + delete transports['parse-server-error']; + } else if (!_lodash2.default.isUndefined(options.dirname)) { + transports['parse-server'] = new _winstonDailyRotateFile2.default(Object.assign({}, { + filename: 'parse-server.info', + name: 'parse-server' + }, options, { timestamp: true })); + transports['parse-server-error'] = new _winstonDailyRotateFile2.default(Object.assign({}, { + filename: 'parse-server.err', + name: 'parse-server-error' + }, options, { level: 'error', timestamp: true })); + } + + transports.console = new _winston2.default.transports.Console(Object.assign({ + colorize: true, + name: 'console', + silent + }, options)); + } + // Mount the additional transports + additionalTransports.forEach(transport => { + transports[transport.name] = transport; + }); + logger.configure({ + transports: _lodash2.default.values(transports) + }); +} + +function configureLogger({ + logsFolder = _defaults2.default.logsFolder, + jsonLogs = _defaults2.default.jsonLogs, + logLevel = _winston2.default.level, + verbose = _defaults2.default.verbose, + silent = _defaults2.default.silent } = {}) { + + if (verbose) { + logLevel = 'verbose'; + } + + _winston2.default.level = logLevel; + const options = {}; + + if (logsFolder) { + if (!_path2.default.isAbsolute(logsFolder)) { + logsFolder = _path2.default.resolve(process.cwd(), logsFolder); + } + try { + _fs2.default.mkdirSync(logsFolder); + } catch (e) {/* */} + } + options.dirname = logsFolder; + options.level = logLevel; + options.silent = silent; + + if (jsonLogs) { + options.json = true; + options.stringify = true; + } + updateTransports(options); +} + +function addTransport(transport) { + additionalTransports.push(transport); + updateTransports(); +} + +function removeTransport(transport) { + const transportName = typeof transport == 'string' ? transport : transport.name; + const transports = Object.assign({}, logger.transports); + delete transports[transportName]; + logger.configure({ + transports: _lodash2.default.values(transports) + }); + _lodash2.default.remove(additionalTransports, transport => { + return transport.name === transportName; + }); +} + +exports.logger = logger; +exports.default = logger; \ No newline at end of file diff --git a/lib/Adapters/Logger/WinstonLoggerAdapter.js b/lib/Adapters/Logger/WinstonLoggerAdapter.js new file mode 100644 index 0000000000..0ea0a02cf7 --- /dev/null +++ b/lib/Adapters/Logger/WinstonLoggerAdapter.js @@ -0,0 +1,71 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.WinstonLoggerAdapter = undefined; + +var _LoggerAdapter = require('./LoggerAdapter'); + +var _WinstonLogger = require('./WinstonLogger'); + +const MILLISECONDS_IN_A_DAY = 24 * 60 * 60 * 1000; + +class WinstonLoggerAdapter extends _LoggerAdapter.LoggerAdapter { + constructor(options) { + super(); + if (options) { + (0, _WinstonLogger.configureLogger)(options); + } + } + + log() { + return _WinstonLogger.logger.log.apply(_WinstonLogger.logger, arguments); + } + + addTransport(transport) { + // Note that this is calling addTransport + // from logger. See import - confusing. + // but this is not recursive. + (0, _WinstonLogger.addTransport)(transport); + } + + // custom query as winston is currently limited + query(options, callback = () => {}) { + if (!options) { + options = {}; + } + // defaults to 7 days prior + const from = options.from || new Date(Date.now() - 7 * MILLISECONDS_IN_A_DAY); + const until = options.until || new Date(); + const limit = options.size || 10; + const order = options.order || 'desc'; + const level = options.level || 'info'; + + const queryOptions = { + from, + until, + limit, + order + }; + + return new Promise((resolve, reject) => { + _WinstonLogger.logger.query(queryOptions, (err, res) => { + if (err) { + callback(err); + return reject(err); + } + if (level == 'error') { + callback(res['parse-server-error']); + resolve(res['parse-server-error']); + } else { + callback(res['parse-server']); + resolve(res['parse-server']); + } + }); + }); + } +} + +exports.WinstonLoggerAdapter = WinstonLoggerAdapter; +exports.default = WinstonLoggerAdapter; \ No newline at end of file diff --git a/lib/Adapters/MessageQueue/EventEmitterMQ.js b/lib/Adapters/MessageQueue/EventEmitterMQ.js new file mode 100644 index 0000000000..c25e1c2076 --- /dev/null +++ b/lib/Adapters/MessageQueue/EventEmitterMQ.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.EventEmitterMQ = undefined; + +var _events = require('events'); + +var _events2 = _interopRequireDefault(_events); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const emitter = new _events2.default.EventEmitter(); +const subscriptions = new Map(); + +function unsubscribe(channel) { + if (!subscriptions.has(channel)) { + //console.log('No channel to unsub from'); + return; + } + //console.log('unsub ', channel); + emitter.removeListener(channel, subscriptions.get(channel)); + subscriptions.delete(channel); +} + +class Publisher { + + constructor(emitter) { + this.emitter = emitter; + } + + publish(channel, message) { + this.emitter.emit(channel, message); + } +} + +class Consumer extends _events2.default.EventEmitter { + + constructor(emitter) { + super(); + this.emitter = emitter; + } + + subscribe(channel) { + unsubscribe(channel); + const handler = message => { + this.emit('message', channel, message); + }; + subscriptions.set(channel, handler); + this.emitter.on(channel, handler); + } + + unsubscribe(channel) { + unsubscribe(channel); + } +} + +function createPublisher() { + return new Publisher(emitter); +} + +function createSubscriber() { + return new Consumer(emitter); +} + +const EventEmitterMQ = { + createPublisher, + createSubscriber +}; + +exports.EventEmitterMQ = EventEmitterMQ; \ No newline at end of file diff --git a/lib/Adapters/PubSub/EventEmitterPubSub.js b/lib/Adapters/PubSub/EventEmitterPubSub.js new file mode 100644 index 0000000000..b878353d74 --- /dev/null +++ b/lib/Adapters/PubSub/EventEmitterPubSub.js @@ -0,0 +1,65 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.EventEmitterPubSub = undefined; + +var _events = require('events'); + +var _events2 = _interopRequireDefault(_events); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const emitter = new _events2.default.EventEmitter(); + +class Publisher { + + constructor(emitter) { + this.emitter = emitter; + } + + publish(channel, message) { + this.emitter.emit(channel, message); + } +} + +class Subscriber extends _events2.default.EventEmitter { + + constructor(emitter) { + super(); + this.emitter = emitter; + this.subscriptions = new Map(); + } + + subscribe(channel) { + const handler = message => { + this.emit('message', channel, message); + }; + this.subscriptions.set(channel, handler); + this.emitter.on(channel, handler); + } + + unsubscribe(channel) { + if (!this.subscriptions.has(channel)) { + return; + } + this.emitter.removeListener(channel, this.subscriptions.get(channel)); + this.subscriptions.delete(channel); + } +} + +function createPublisher() { + return new Publisher(emitter); +} + +function createSubscriber() { + return new Subscriber(emitter); +} + +const EventEmitterPubSub = { + createPublisher, + createSubscriber +}; + +exports.EventEmitterPubSub = EventEmitterPubSub; \ No newline at end of file diff --git a/lib/Adapters/PubSub/RedisPubSub.js b/lib/Adapters/PubSub/RedisPubSub.js new file mode 100644 index 0000000000..bb84311735 --- /dev/null +++ b/lib/Adapters/PubSub/RedisPubSub.js @@ -0,0 +1,68 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.createSubscriber = exports.createPublisher = exports.RedisPubSub = undefined; + +var _redis = require('redis'); + +var _redis2 = _interopRequireDefault(_redis); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function createPublisher({ redisURL }) { + var redisCli = _redis2.default.createClient(redisURL, { no_ready_check: true }); + + if (redisCli) { + redisCli.publish2 = redisCli.publish; + + redisCli.publish = function (channel, body) { + var bodyObject; + try { + bodyObject = JSON.parse(body); + } catch (e) { + bodyObject = {}; + } + if (bodyObject && bodyObject.pushStatus) { + redisCli.multi([['sadd', bodyObject.applicationId + ':push', body]]).exec(); + } + return redisCli.publish2(channel, body); + }; + } + + return redisCli; +} + +function createSubscriber({ redisURL }) { + var redisCli = _redis2.default.createClient(redisURL, { no_ready_check: true }); + var secondaryClient = _redis2.default.createClient(redisURL, { no_ready_check: true }); + if (redisCli) { + redisCli.run = function (workItem) { + return new _node2.default.Promise(function (resolve) { + secondaryClient.multi([['spop', workItem.applicationId + ':push']]).exec(function (err, rep) { + if (!err && rep && rep[0]) { + resolve(JSON.parse(rep[0])); + } else { + resolve(); + } + }); + }); + }; + } + + return redisCli; +} + +const RedisPubSub = { + createPublisher, + createSubscriber +}; + +exports.RedisPubSub = RedisPubSub; +exports.createPublisher = createPublisher; +exports.createSubscriber = createSubscriber; \ No newline at end of file diff --git a/lib/Adapters/Push/PushAdapter.js b/lib/Adapters/Push/PushAdapter.js new file mode 100644 index 0000000000..d8080c5328 --- /dev/null +++ b/lib/Adapters/Push/PushAdapter.js @@ -0,0 +1,32 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +/*eslint no-unused-vars: "off"*/ +// Push Adapter +// +// Allows you to change the push notification mechanism. +// +// Adapter classes must implement the following functions: +// * getValidPushTypes() +// * send(devices, installations, pushStatus) +// +// Default is ParsePushAdapter, which uses GCM for +// android push and APNS for ios push. + +class PushAdapter { + send(body, installations, pushStatus) {} + + /** + * Get an array of valid push types. + * @returns {Array} An array of valid push types + */ + getValidPushTypes() { + return []; + } +} + +exports.PushAdapter = PushAdapter; +exports.default = PushAdapter; \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoCollection.js b/lib/Adapters/Storage/Mongo/MongoCollection.js new file mode 100644 index 0000000000..7e9c22c2b6 --- /dev/null +++ b/lib/Adapters/Storage/Mongo/MongoCollection.js @@ -0,0 +1,112 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +const mongodb = require('mongodb'); +const Collection = mongodb.Collection; + +class MongoCollection { + + constructor(mongoCollection) { + this._mongoCollection = mongoCollection; + } + + // Does a find with "smart indexing". + // Currently this just means, if it needs a geoindex and there is + // none, then build the geoindex. + // This could be improved a lot but it's not clear if that's a good + // idea. Or even if this behavior is a good idea. + find(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) { + // Support for Full Text Search - $text + if (keys && keys.$score) { + delete keys.$score; + keys.score = { $meta: 'textScore' }; + } + return this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference }).catch(error => { + // Check for "no geoindex" error + if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) { + throw error; + } + // Figure out what key needs an index + const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1]; + if (!key) { + throw error; + } + + var index = {}; + index[key] = '2d'; + return this._mongoCollection.createIndex(index) + // Retry, but just once. + .then(() => this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference })); + }); + } + + _rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) { + let findOperation = this._mongoCollection.find(query, { skip, limit, sort, readPreference }); + + if (keys) { + findOperation = findOperation.project(keys); + } + + if (maxTimeMS) { + findOperation = findOperation.maxTimeMS(maxTimeMS); + } + + return findOperation.toArray(); + } + + count(query, { skip, limit, sort, maxTimeMS, readPreference } = {}) { + const countOperation = this._mongoCollection.count(query, { skip, limit, sort, maxTimeMS, readPreference }); + + return countOperation; + } + + distinct(field, query) { + return this._mongoCollection.distinct(field, query); + } + + aggregate(pipeline, { maxTimeMS, readPreference } = {}) { + return this._mongoCollection.aggregate(pipeline, { maxTimeMS, readPreference }).toArray(); + } + + insertOne(object) { + return this._mongoCollection.insertOne(object); + } + + // Atomically updates data in the database for a single (first) object that matched the query + // If there is nothing that matches the query - does insert + // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5. + upsertOne(query, update) { + return this._mongoCollection.update(query, update, { upsert: true }); + } + + updateOne(query, update) { + return this._mongoCollection.updateOne(query, update); + } + + updateMany(query, update) { + return this._mongoCollection.updateMany(query, update); + } + + deleteMany(query) { + return this._mongoCollection.deleteMany(query); + } + + _ensureSparseUniqueIndexInBackground(indexRequest) { + return new Promise((resolve, reject) => { + this._mongoCollection.ensureIndex(indexRequest, { unique: true, background: true, sparse: true }, error => { + if (error) { + reject(error); + } else { + resolve(); + } + }); + }); + } + + drop() { + return this._mongoCollection.drop(); + } +} +exports.default = MongoCollection; \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js b/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js new file mode 100644 index 0000000000..c987723ccc --- /dev/null +++ b/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js @@ -0,0 +1,227 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +var _MongoCollection = require('./MongoCollection'); + +var _MongoCollection2 = _interopRequireDefault(_MongoCollection); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function mongoFieldToParseSchemaField(type) { + if (type[0] === '*') { + return { + type: 'Pointer', + targetClass: type.slice(1) + }; + } + if (type.startsWith('relation<')) { + return { + type: 'Relation', + targetClass: type.slice('relation<'.length, type.length - 1) + }; + } + switch (type) { + case 'number': + return { type: 'Number' }; + case 'string': + return { type: 'String' }; + case 'boolean': + return { type: 'Boolean' }; + case 'date': + return { type: 'Date' }; + case 'map': + case 'object': + return { type: 'Object' }; + case 'array': + return { type: 'Array' }; + case 'geopoint': + return { type: 'GeoPoint' }; + case 'file': + return { type: 'File' }; + case 'bytes': + return { type: 'Bytes' }; + case 'polygon': + return { type: 'Polygon' }; + } +} + +const nonFieldSchemaKeys = ['_id', '_metadata', '_client_permissions']; +function mongoSchemaFieldsToParseSchemaFields(schema) { + var fieldNames = Object.keys(schema).filter(key => nonFieldSchemaKeys.indexOf(key) === -1); + var response = fieldNames.reduce((obj, fieldName) => { + obj[fieldName] = mongoFieldToParseSchemaField(schema[fieldName]); + return obj; + }, {}); + response.ACL = { type: 'ACL' }; + response.createdAt = { type: 'Date' }; + response.updatedAt = { type: 'Date' }; + response.objectId = { type: 'String' }; + return response; +} + +const emptyCLPS = Object.freeze({ + find: {}, + get: {}, + create: {}, + update: {}, + delete: {}, + addField: {} +}); + +const defaultCLPS = Object.freeze({ + find: { '*': true }, + get: { '*': true }, + create: { '*': true }, + update: { '*': true }, + delete: { '*': true }, + addField: { '*': true } +}); + +function mongoSchemaToParseSchema(mongoSchema) { + let clps = defaultCLPS; + let indexes = {}; + if (mongoSchema._metadata) { + if (mongoSchema._metadata.class_permissions) { + clps = _extends({}, emptyCLPS, mongoSchema._metadata.class_permissions); + } + if (mongoSchema._metadata.indexes) { + indexes = _extends({}, mongoSchema._metadata.indexes); + } + } + return { + className: mongoSchema._id, + fields: mongoSchemaFieldsToParseSchemaFields(mongoSchema), + classLevelPermissions: clps, + indexes: indexes + }; +} + +function _mongoSchemaQueryFromNameQuery(name, query) { + const object = { _id: name }; + if (query) { + Object.keys(query).forEach(key => { + object[key] = query[key]; + }); + } + return object; +} + +// Returns a type suitable for inserting into mongo _SCHEMA collection. +// Does no validation. That is expected to be done in Parse Server. +function parseFieldTypeToMongoFieldType({ type, targetClass }) { + switch (type) { + case 'Pointer': + return `*${targetClass}`; + case 'Relation': + return `relation<${targetClass}>`; + case 'Number': + return 'number'; + case 'String': + return 'string'; + case 'Boolean': + return 'boolean'; + case 'Date': + return 'date'; + case 'Object': + return 'object'; + case 'Array': + return 'array'; + case 'GeoPoint': + return 'geopoint'; + case 'File': + return 'file'; + case 'Bytes': + return 'bytes'; + case 'Polygon': + return 'polygon'; + } +} + +class MongoSchemaCollection { + + constructor(collection) { + this._collection = collection; + } + + _fetchAllSchemasFrom_SCHEMA() { + return this._collection._rawFind({}).then(schemas => schemas.map(mongoSchemaToParseSchema)); + } + + _fetchOneSchemaFrom_SCHEMA(name) { + return this._collection._rawFind(_mongoSchemaQueryFromNameQuery(name), { limit: 1 }).then(results => { + if (results.length === 1) { + return mongoSchemaToParseSchema(results[0]); + } else { + throw undefined; + } + }); + } + + // Atomically find and delete an object based on query. + findAndDeleteSchema(name) { + return this._collection._mongoCollection.findAndRemove(_mongoSchemaQueryFromNameQuery(name), []); + } + + updateSchema(name, update) { + return this._collection.updateOne(_mongoSchemaQueryFromNameQuery(name), update); + } + + upsertSchema(name, query, update) { + return this._collection.upsertOne(_mongoSchemaQueryFromNameQuery(name, query), update); + } + + // Add a field to the schema. If database does not support the field + // type (e.g. mongo doesn't support more than one GeoPoint in a class) reject with an "Incorrect Type" + // Parse error with a desciptive message. If the field already exists, this function must + // not modify the schema, and must reject with DUPLICATE_VALUE error. + // If this is called for a class that doesn't exist, this function must create that class. + + // TODO: throw an error if an unsupported field type is passed. Deciding whether a type is supported + // should be the job of the adapter. Some adapters may not support GeoPoint at all. Others may + // Support additional types that Mongo doesn't, like Money, or something. + + // TODO: don't spend an extra query on finding the schema if the type we are trying to add isn't a GeoPoint. + addFieldIfNotExists(className, fieldName, type) { + return this._fetchOneSchemaFrom_SCHEMA(className).then(schema => { + // If a field with this name already exists, it will be handled elsewhere. + if (schema.fields[fieldName] != undefined) { + return; + } + // The schema exists. Check for existing GeoPoints. + if (type.type === 'GeoPoint') { + // Make sure there are not other geopoint fields + if (Object.keys(schema.fields).some(existingField => schema.fields[existingField].type === 'GeoPoint')) { + throw new _node2.default.Error(_node2.default.Error.INCORRECT_TYPE, 'MongoDB only supports one GeoPoint field in a class.'); + } + } + return; + }, error => { + // If error is undefined, the schema doesn't exist, and we can create the schema with the field. + // If some other error, reject with it. + if (error === undefined) { + return; + } + throw error; + }).then(() => { + // We use $exists and $set to avoid overwriting the field type if it + // already exists. (it could have added inbetween the last query and the update) + return this.upsertSchema(className, { [fieldName]: { '$exists': false } }, { '$set': { [fieldName]: parseFieldTypeToMongoFieldType(type) } }); + }); + } +} + +// Exported for testing reasons and because we haven't moved all mongo schema format +// related logic into the database adapter yet. +MongoSchemaCollection._TESTmongoSchemaToParseSchema = mongoSchemaToParseSchema; +MongoSchemaCollection.parseFieldTypeToMongoFieldType = parseFieldTypeToMongoFieldType; + +exports.default = MongoSchemaCollection; \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js new file mode 100644 index 0000000000..fbde2bed67 --- /dev/null +++ b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -0,0 +1,578 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.MongoStorageAdapter = undefined; + +var _MongoCollection = require('./MongoCollection'); + +var _MongoCollection2 = _interopRequireDefault(_MongoCollection); + +var _MongoSchemaCollection = require('./MongoSchemaCollection'); + +var _MongoSchemaCollection2 = _interopRequireDefault(_MongoSchemaCollection); + +var _mongodbUrl = require('../../../vendor/mongodbUrl'); + +var _MongoTransform = require('./MongoTransform'); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _defaults = require('../../../defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + +const mongodb = require('mongodb'); +const MongoClient = mongodb.MongoClient; +const ReadPreference = mongodb.ReadPreference; + +const MongoSchemaCollectionName = '_SCHEMA'; + +const storageAdapterAllCollections = mongoAdapter => { + return mongoAdapter.connect().then(() => mongoAdapter.database.collections()).then(collections => { + return collections.filter(collection => { + if (collection.namespace.match(/\.system\./)) { + return false; + } + // TODO: If you have one app with a collection prefix that happens to be a prefix of another + // apps prefix, this will go very very badly. We should fix that somehow. + return collection.collectionName.indexOf(mongoAdapter._collectionPrefix) == 0; + }); + }); +}; + +const convertParseSchemaToMongoSchema = (_ref) => { + let schema = _objectWithoutProperties(_ref, []); + + delete schema.fields._rperm; + delete schema.fields._wperm; + + if (schema.className === '_User') { + // Legacy mongo adapter knows about the difference between password and _hashed_password. + // Future database adapters will only know about _hashed_password. + // Note: Parse Server will bring back password with injectDefaultSchema, so we don't need + // to add _hashed_password back ever. + delete schema.fields._hashed_password; + } + + return schema; +}; + +// Returns { code, error } if invalid, or { result }, an object +// suitable for inserting into _SCHEMA collection, otherwise. +const mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPermissions, indexes) => { + const mongoObject = { + _id: className, + objectId: 'string', + updatedAt: 'string', + createdAt: 'string' + }; + + for (const fieldName in fields) { + mongoObject[fieldName] = _MongoSchemaCollection2.default.parseFieldTypeToMongoFieldType(fields[fieldName]); + } + + if (typeof classLevelPermissions !== 'undefined') { + mongoObject._metadata = mongoObject._metadata || {}; + if (!classLevelPermissions) { + delete mongoObject._metadata.class_permissions; + } else { + mongoObject._metadata.class_permissions = classLevelPermissions; + } + } + + if (indexes && typeof indexes === 'object' && Object.keys(indexes).length > 0) { + mongoObject._metadata = mongoObject._metadata || {}; + mongoObject._metadata.indexes = indexes; + } + + return mongoObject; +}; + +class MongoStorageAdapter { + // Private + constructor({ + uri = _defaults2.default.DefaultMongoURI, + collectionPrefix = '', + mongoOptions = {} + }) { + this._uri = uri; + this._collectionPrefix = collectionPrefix; + this._mongoOptions = mongoOptions; + + // MaxTimeMS is not a global MongoDB client option, it is applied per operation. + this._maxTimeMS = mongoOptions.maxTimeMS; + this.canSortOnJoinTables = true; + delete mongoOptions.maxTimeMS; + } + // Public + + + connect() { + if (this.connectionPromise) { + return this.connectionPromise; + } + + // parsing and re-formatting causes the auth value (if there) to get URI + // encoded + const encodedUri = (0, _mongodbUrl.format)((0, _mongodbUrl.parse)(this._uri)); + + this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(database => { + if (!database) { + delete this.connectionPromise; + return; + } + database.on('error', () => { + delete this.connectionPromise; + }); + database.on('close', () => { + delete this.connectionPromise; + }); + this.database = database; + }).catch(err => { + delete this.connectionPromise; + return Promise.reject(err); + }); + + return this.connectionPromise; + } + + handleShutdown() { + if (!this.database) { + return; + } + this.database.close(false); + } + + _adaptiveCollection(name) { + return this.connect().then(() => this.database.collection(this._collectionPrefix + name)).then(rawCollection => new _MongoCollection2.default(rawCollection)); + } + + _schemaCollection() { + return this.connect().then(() => this._adaptiveCollection(MongoSchemaCollectionName)).then(collection => new _MongoSchemaCollection2.default(collection)); + } + + classExists(name) { + return this.connect().then(() => { + return this.database.listCollections({ name: this._collectionPrefix + name }).toArray(); + }).then(collections => { + return collections.length > 0; + }); + } + + setClassLevelPermissions(className, CLPs) { + return this._schemaCollection().then(schemaCollection => schemaCollection.updateSchema(className, { + $set: { '_metadata.class_permissions': CLPs } + })); + } + + setIndexesWithSchemaFormat(className, submittedIndexes, existingIndexes = {}, fields) { + if (submittedIndexes === undefined) { + return Promise.resolve(); + } + if (Object.keys(existingIndexes).length === 0) { + existingIndexes = { _id_: { _id: 1 } }; + } + const deletePromises = []; + const insertedIndexes = []; + Object.keys(submittedIndexes).forEach(name => { + const field = submittedIndexes[name]; + if (existingIndexes[name] && field.__op !== 'Delete') { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`); + } + if (!existingIndexes[name] && field.__op === 'Delete') { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`); + } + if (field.__op === 'Delete') { + const promise = this.dropIndex(className, name); + deletePromises.push(promise); + delete existingIndexes[name]; + } else { + Object.keys(field).forEach(key => { + if (!fields.hasOwnProperty(key)) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`); + } + }); + existingIndexes[name] = field; + insertedIndexes.push({ + key: field, + name + }); + } + }); + let insertPromise = Promise.resolve(); + if (insertedIndexes.length > 0) { + insertPromise = this.createIndexes(className, insertedIndexes); + } + return Promise.all(deletePromises).then(() => insertPromise).then(() => this._schemaCollection()).then(schemaCollection => schemaCollection.updateSchema(className, { + $set: { '_metadata.indexes': existingIndexes } + })); + } + + setIndexesFromMongo(className) { + return this.getIndexes(className).then(indexes => { + indexes = indexes.reduce((obj, index) => { + if (index.key._fts) { + delete index.key._fts; + delete index.key._ftsx; + for (const field in index.weights) { + index.key[field] = 'text'; + } + } + obj[index.name] = index.key; + return obj; + }, {}); + return this._schemaCollection().then(schemaCollection => schemaCollection.updateSchema(className, { + $set: { '_metadata.indexes': indexes } + })); + }).catch(() => { + // Ignore if collection not found + return Promise.resolve(); + }); + } + + createClass(className, schema) { + schema = convertParseSchemaToMongoSchema(schema); + const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions, schema.indexes); + mongoObject._id = className; + return this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields).then(() => this._schemaCollection()).then(schemaCollection => schemaCollection._collection.insertOne(mongoObject)).then(result => _MongoSchemaCollection2.default._TESTmongoSchemaToParseSchema(result.ops[0])).catch(error => { + if (error.code === 11000) { + //Mongo's duplicate key error + throw new _node2.default.Error(_node2.default.Error.DUPLICATE_VALUE, 'Class already exists.'); + } else { + throw error; + } + }); + } + + addFieldIfNotExists(className, fieldName, type) { + return this._schemaCollection().then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type)).then(() => this.createIndexesIfNeeded(className, fieldName, type)); + } + + // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.) + // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible. + deleteClass(className) { + return this._adaptiveCollection(className).then(collection => collection.drop()).catch(error => { + // 'ns not found' means collection was already gone. Ignore deletion attempt. + if (error.message == 'ns not found') { + return; + } + throw error; + }) + // We've dropped the collection, now remove the _SCHEMA document + .then(() => this._schemaCollection()).then(schemaCollection => schemaCollection.findAndDeleteSchema(className)); + } + + // Delete all data known to this adapter. Used for testing. + deleteAllClasses() { + return storageAdapterAllCollections(this).then(collections => Promise.all(collections.map(collection => collection.drop()))); + } + + // Remove the column and all the data. For Relations, the _Join collection is handled + // specially, this function does not delete _Join columns. It should, however, indicate + // that the relation fields does not exist anymore. In mongo, this means removing it from + // the _SCHEMA collection. There should be no actual data in the collection under the same name + // as the relation column, so it's fine to attempt to delete it. If the fields listed to be + // deleted do not exist, this function should return successfully anyways. Checking for + // attempts to delete non-existent fields is the responsibility of Parse Server. + + // Pointer field names are passed for legacy reasons: the original mongo + // format stored pointer field names differently in the database, and therefore + // needed to know the type of the field before it could delete it. Future database + // adapters should ignore the pointerFieldNames argument. All the field names are in + // fieldNames, they show up additionally in the pointerFieldNames database for use + // by the mongo adapter, which deals with the legacy mongo format. + + // This function is not obligated to delete fields atomically. It is given the field + // names in a list so that databases that are capable of deleting fields atomically + // may do so. + + // Returns a Promise. + deleteFields(className, schema, fieldNames) { + const mongoFormatNames = fieldNames.map(fieldName => { + if (schema.fields[fieldName].type === 'Pointer') { + return `_p_${fieldName}`; + } else { + return fieldName; + } + }); + const collectionUpdate = { '$unset': {} }; + mongoFormatNames.forEach(name => { + collectionUpdate['$unset'][name] = null; + }); + + const schemaUpdate = { '$unset': {} }; + fieldNames.forEach(name => { + schemaUpdate['$unset'][name] = null; + }); + + return this._adaptiveCollection(className).then(collection => collection.updateMany({}, collectionUpdate)).then(() => this._schemaCollection()).then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate)); + } + + // Return a promise for all schemas known to this adapter, in Parse format. In case the + // schemas cannot be retrieved, returns a promise that rejects. Requirements for the + // rejection reason are TBD. + getAllClasses() { + return this._schemaCollection().then(schemasCollection => schemasCollection._fetchAllSchemasFrom_SCHEMA()); + } + + // Return a promise for the schema with the given name, in Parse format. If + // this adapter doesn't know about the schema, return a promise that rejects with + // undefined as the reason. + getClass(className) { + return this._schemaCollection().then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className)); + } + + // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema, + // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs + // the schema only for the legacy mongo format. We'll figure that out later. + createObject(className, schema, object) { + schema = convertParseSchemaToMongoSchema(schema); + const mongoObject = (0, _MongoTransform.parseObjectToMongoObjectForCreate)(className, object, schema); + return this._adaptiveCollection(className).then(collection => collection.insertOne(mongoObject)).catch(error => { + if (error.code === 11000) { + // Duplicate value + const err = new _node2.default.Error(_node2.default.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided'); + err.underlyingError = error; + if (error.message) { + const matches = error.message.match(/index:[\sa-zA-Z0-9_\-\.]+\$?([a-zA-Z_-]+)_1/); + if (matches && Array.isArray(matches)) { + err.userInfo = { duplicated_field: matches[1] }; + } + } + throw err; + } + throw error; + }); + } + + // Remove all objects that match the given Parse Query. + // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined. + // If there is some other error, reject with INTERNAL_SERVER_ERROR. + deleteObjectsByQuery(className, schema, query) { + schema = convertParseSchemaToMongoSchema(schema); + return this._adaptiveCollection(className).then(collection => { + const mongoWhere = (0, _MongoTransform.transformWhere)(className, query, schema); + return collection.deleteMany(mongoWhere); + }).then(({ result }) => { + if (result.n === 0) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Object not found.'); + } + return Promise.resolve(); + }, () => { + throw new _node2.default.Error(_node2.default.Error.INTERNAL_SERVER_ERROR, 'Database adapter error'); + }); + } + + // Apply the update to all objects that match the given Parse Query. + updateObjectsByQuery(className, schema, query, update) { + schema = convertParseSchemaToMongoSchema(schema); + const mongoUpdate = (0, _MongoTransform.transformUpdate)(className, update, schema); + const mongoWhere = (0, _MongoTransform.transformWhere)(className, query, schema); + return this._adaptiveCollection(className).then(collection => collection.updateMany(mongoWhere, mongoUpdate)); + } + + // Atomically finds and updates an object based on query. + // Return value not currently well specified. + findOneAndUpdate(className, schema, query, update) { + schema = convertParseSchemaToMongoSchema(schema); + const mongoUpdate = (0, _MongoTransform.transformUpdate)(className, update, schema); + const mongoWhere = (0, _MongoTransform.transformWhere)(className, query, schema); + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.findAndModify(mongoWhere, [], mongoUpdate, { new: true })).then(result => (0, _MongoTransform.mongoObjectToParseObject)(className, result.value, schema)); + } + + // Hopefully we can get rid of this. It's only used for config and hooks. + upsertOneObject(className, schema, query, update) { + schema = convertParseSchemaToMongoSchema(schema); + const mongoUpdate = (0, _MongoTransform.transformUpdate)(className, update, schema); + const mongoWhere = (0, _MongoTransform.transformWhere)(className, query, schema); + return this._adaptiveCollection(className).then(collection => collection.upsertOne(mongoWhere, mongoUpdate)); + } + + // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }. + find(className, schema, query, { skip, limit, sort, keys, readPreference }) { + schema = convertParseSchemaToMongoSchema(schema); + const mongoWhere = (0, _MongoTransform.transformWhere)(className, query, schema); + const mongoSort = _lodash2.default.mapKeys(sort, (value, fieldName) => (0, _MongoTransform.transformKey)(className, fieldName, schema)); + const mongoKeys = _lodash2.default.reduce(keys, (memo, key) => { + memo[(0, _MongoTransform.transformKey)(className, key, schema)] = 1; + return memo; + }, {}); + + readPreference = this._parseReadPreference(readPreference); + return this.createTextIndexesIfNeeded(className, query, schema).then(() => this._adaptiveCollection(className)).then(collection => collection.find(mongoWhere, { + skip, + limit, + sort: mongoSort, + keys: mongoKeys, + maxTimeMS: this._maxTimeMS, + readPreference + })).then(objects => objects.map(object => (0, _MongoTransform.mongoObjectToParseObject)(className, object, schema))); + } + + // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't + // currently know which fields are nullable and which aren't, we ignore that criteria. + // As such, we shouldn't expose this function to users of parse until we have an out-of-band + // Way of determining if a field is nullable. Undefined doesn't count against uniqueness, + // which is why we use sparse indexes. + ensureUniqueness(className, schema, fieldNames) { + schema = convertParseSchemaToMongoSchema(schema); + const indexCreationRequest = {}; + const mongoFieldNames = fieldNames.map(fieldName => (0, _MongoTransform.transformKey)(className, fieldName, schema)); + mongoFieldNames.forEach(fieldName => { + indexCreationRequest[fieldName] = 1; + }); + return this._adaptiveCollection(className).then(collection => collection._ensureSparseUniqueIndexInBackground(indexCreationRequest)).catch(error => { + if (error.code === 11000) { + throw new _node2.default.Error(_node2.default.Error.DUPLICATE_VALUE, 'Tried to ensure field uniqueness for a class that already has duplicates.'); + } + throw error; + }); + } + + // Used in tests + _rawFind(className, query) { + return this._adaptiveCollection(className).then(collection => collection.find(query, { + maxTimeMS: this._maxTimeMS + })); + } + + // Executes a count. + count(className, schema, query, readPreference) { + schema = convertParseSchemaToMongoSchema(schema); + readPreference = this._parseReadPreference(readPreference); + return this._adaptiveCollection(className).then(collection => collection.count((0, _MongoTransform.transformWhere)(className, query, schema), { + maxTimeMS: this._maxTimeMS, + readPreference + })); + } + + distinct(className, schema, query, fieldName) { + schema = convertParseSchemaToMongoSchema(schema); + return this._adaptiveCollection(className).then(collection => collection.distinct(fieldName, (0, _MongoTransform.transformWhere)(className, query, schema))).then(objects => objects.map(object => (0, _MongoTransform.mongoObjectToParseObject)(className, object, schema))); + } + + aggregate(className, schema, pipeline, readPreference) { + readPreference = this._parseReadPreference(readPreference); + return this._adaptiveCollection(className).then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS })).then(results => { + results.forEach(result => { + if (result.hasOwnProperty('_id')) { + result.objectId = result._id; + delete result._id; + } + }); + return results; + }).then(objects => objects.map(object => (0, _MongoTransform.mongoObjectToParseObject)(className, object, schema))); + } + + _parseReadPreference(readPreference) { + if (readPreference) { + switch (readPreference) { + case 'PRIMARY': + readPreference = ReadPreference.PRIMARY; + break; + case 'PRIMARY_PREFERRED': + readPreference = ReadPreference.PRIMARY_PREFERRED; + break; + case 'SECONDARY': + readPreference = ReadPreference.SECONDARY; + break; + case 'SECONDARY_PREFERRED': + readPreference = ReadPreference.SECONDARY_PREFERRED; + break; + case 'NEAREST': + readPreference = ReadPreference.NEAREST; + break; + default: + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, 'Not supported read preference.'); + } + } + return readPreference; + } + + performInitialization() { + return Promise.resolve(); + } + + createIndex(className, index) { + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.createIndex(index)); + } + + createIndexes(className, indexes) { + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.createIndexes(indexes)); + } + + createIndexesIfNeeded(className, fieldName, type) { + if (type && type.type === 'Polygon') { + const index = { + [fieldName]: '2dsphere' + }; + return this.createIndex(className, index); + } + return Promise.resolve(); + } + + createTextIndexesIfNeeded(className, query, schema) { + for (const fieldName in query) { + if (!query[fieldName] || !query[fieldName].$text) { + continue; + } + const existingIndexes = schema.indexes; + for (const key in existingIndexes) { + const index = existingIndexes[key]; + if (index.hasOwnProperty(fieldName)) { + return Promise.resolve(); + } + } + const indexName = `${fieldName}_text`; + const textIndex = { + [indexName]: { [fieldName]: 'text' } + }; + return this.setIndexesWithSchemaFormat(className, textIndex, existingIndexes, schema.fields).catch(error => { + if (error.code === 85) { + // Index exist with different options + return this.setIndexesFromMongo(className); + } + throw error; + }); + } + return Promise.resolve(); + } + + getIndexes(className) { + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.indexes()); + } + + dropIndex(className, index) { + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.dropIndex(index)); + } + + dropAllIndexes(className) { + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.dropIndexes()); + } + + updateSchemaWithIndexes() { + return this.getAllClasses().then(classes => { + const promises = classes.map(schema => { + return this.setIndexesFromMongo(schema.className); + }); + return Promise.all(promises); + }); + } +} + +exports.MongoStorageAdapter = MongoStorageAdapter; +exports.default = MongoStorageAdapter; + +module.exports = MongoStorageAdapter; // Required for tests \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoTransform.js b/lib/Adapters/Storage/Mongo/MongoTransform.js new file mode 100644 index 0000000000..5a39ba79c9 --- /dev/null +++ b/lib/Adapters/Storage/Mongo/MongoTransform.js @@ -0,0 +1,1314 @@ +'use strict'; + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +var _logger = require('../../../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var mongodb = require('mongodb'); +var Parse = require('parse/node').Parse; + +const transformKey = (className, fieldName, schema) => { + // Check if the schema is known since it's a built-in field. + switch (fieldName) { + case 'objectId': + return '_id'; + case 'createdAt': + return '_created_at'; + case 'updatedAt': + return '_updated_at'; + case 'sessionToken': + return '_session_token'; + case 'lastUsed': + return '_last_used'; + case 'timesUsed': + return 'times_used'; + } + + if (schema.fields[fieldName] && schema.fields[fieldName].__type == 'Pointer') { + fieldName = '_p_' + fieldName; + } else if (schema.fields[fieldName] && schema.fields[fieldName].type == 'Pointer') { + fieldName = '_p_' + fieldName; + } + + return fieldName; +}; + +const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSchema) => { + // 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': + if (className === '_GlobalConfig') { + return { + key: key, + value: parseInt(restValue) + }; + } + key = '_id'; + break; + case 'createdAt': + case '_created_at': + key = '_created_at'; + timeField = true; + break; + case 'updatedAt': + case '_updated_at': + key = '_updated_at'; + timeField = true; + break; + case 'sessionToken': + case '_session_token': + key = '_session_token'; + break; + case 'expiresAt': + case '_expiresAt': + key = 'expiresAt'; + timeField = true; + break; + case '_email_verify_token_expires_at': + key = '_email_verify_token_expires_at'; + timeField = true; + break; + case '_account_lockout_expires_at': + key = '_account_lockout_expires_at'; + timeField = true; + break; + case '_failed_login_count': + key = '_failed_login_count'; + break; + case '_perishable_token_expires_at': + key = '_perishable_token_expires_at'; + timeField = true; + break; + case '_password_changed_at': + key = '_password_changed_at'; + timeField = true; + break; + case '_rperm': + case '_wperm': + return { key: key, value: restValue }; + case 'lastUsed': + case '_last_used': + key = '_last_used'; + timeField = true; + break; + case 'timesUsed': + case 'times_used': + key = 'times_used'; + timeField = true; + break; + } + + if (parseFormatSchema.fields[key] && parseFormatSchema.fields[key].type === 'Pointer' || !parseFormatSchema.fields[key] && restValue && restValue.__type == 'Pointer') { + key = '_p_' + key; + } + + // Handle atomic values + var value = transformTopLevelAtom(restValue); + if (value !== CannotTransform) { + if (timeField && typeof value === 'string') { + value = new Date(value); + } + if (restKey.indexOf('.') > 0) { + return { key, value: restValue }; + } + return { key, value }; + } + + // Handle arrays + if (restValue instanceof Array) { + value = restValue.map(transformInteriorValue); + return { key, value }; + } + + // Handle update operators + if (typeof restValue === 'object' && '__op' in restValue) { + return { key, value: transformUpdateOperator(restValue, false) }; + } + + // Handle normal objects by recursing + value = mapValues(restValue, transformInteriorValue); + return { key, value }; +}; + +const transformInteriorValue = restValue => { + 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 + var value = transformInteriorAtom(restValue); + if (value !== CannotTransform) { + return value; + } + + // Handle arrays + if (restValue instanceof Array) { + return restValue.map(transformInteriorValue); + } + + // Handle update operators + if (typeof restValue === 'object' && '__op' in restValue) { + return transformUpdateOperator(restValue, true); + } + + // Handle normal objects by recursing + return mapValues(restValue, transformInteriorValue); +}; + +const valueAsDate = value => { + if (typeof value === 'string') { + return new Date(value); + } else if (value instanceof Date) { + return value; + } + return false; +}; + +function transformQueryKeyValue(className, key, value, schema) { + switch (key) { + case 'createdAt': + if (valueAsDate(value)) { + return { key: '_created_at', value: valueAsDate(value) }; + } + key = '_created_at'; + break; + case 'updatedAt': + if (valueAsDate(value)) { + return { key: '_updated_at', value: valueAsDate(value) }; + } + key = '_updated_at'; + break; + case 'expiresAt': + if (valueAsDate(value)) { + return { key: 'expiresAt', value: valueAsDate(value) }; + } + break; + case '_email_verify_token_expires_at': + if (valueAsDate(value)) { + return { key: '_email_verify_token_expires_at', value: valueAsDate(value) }; + } + break; + case 'objectId': + { + if (className === '_GlobalConfig') { + value = parseInt(value); + } + return { key: '_id', value }; + } + case '_account_lockout_expires_at': + if (valueAsDate(value)) { + return { key: '_account_lockout_expires_at', value: valueAsDate(value) }; + } + break; + case '_failed_login_count': + return { key, value }; + case 'sessionToken': + return { key: '_session_token', value }; + case '_perishable_token_expires_at': + if (valueAsDate(value)) { + return { key: '_perishable_token_expires_at', value: valueAsDate(value) }; + } + break; + case '_password_changed_at': + if (valueAsDate(value)) { + return { key: '_password_changed_at', value: valueAsDate(value) }; + } + break; + case '_rperm': + case '_wperm': + case '_perishable_token': + case '_email_verify_token': + return { key, value }; + case '$or': + return { key: '$or', value: value.map(subQuery => transformWhere(className, subQuery, schema)) }; + case '$and': + return { key: '$and', value: value.map(subQuery => transformWhere(className, subQuery, schema)) }; + case 'lastUsed': + if (valueAsDate(value)) { + return { key: '_last_used', value: valueAsDate(value) }; + } + key = '_last_used'; + break; + case 'timesUsed': + return { key: 'times_used', value: value }; + default: + { + // Other auth data + const authDataMatch = key.match(/^authData\.([a-zA-Z0-9_]+)\.id$/); + if (authDataMatch) { + const provider = authDataMatch[1]; + // Special-case auth data. + return { key: `_auth_data_${provider}.id`, value }; + } + } + } + + const expectedTypeIsArray = schema && schema.fields[key] && schema.fields[key].type === 'Array'; + + const expectedTypeIsPointer = schema && schema.fields[key] && schema.fields[key].type === 'Pointer'; + + const field = schema && schema.fields[key]; + if (expectedTypeIsPointer || !schema && value && value.__type === 'Pointer') { + key = '_p_' + key; + } + + // Handle query constraints + const transformedConstraint = transformConstraint(value, field); + if (transformedConstraint !== CannotTransform) { + if (transformedConstraint.$text) { + return { key: '$text', value: transformedConstraint.$text }; + } + return { key, value: transformedConstraint }; + } + + if (expectedTypeIsArray && !(value instanceof Array)) { + return { key, value: { '$all': [transformInteriorAtom(value)] } }; + } + + // Handle atomic values + if (transformTopLevelAtom(value) !== CannotTransform) { + return { key, value: transformTopLevelAtom(value) }; + } else { + throw new Parse.Error(Parse.Error.INVALID_JSON, `You cannot use ${value} as a query parameter.`); + } +} + +// Main exposed method to help run queries. +// restWhere is the "where" clause in REST API form. +// Returns the mongo form of the query. +function transformWhere(className, restWhere, schema) { + const mongoWhere = {}; + for (const restKey in restWhere) { + const out = transformQueryKeyValue(className, restKey, restWhere[restKey], schema); + mongoWhere[out.key] = out.value; + } + return mongoWhere; +} + +const parseObjectKeyValueToMongoObjectKeyValue = (restKey, restValue, schema) => { + // Check if the schema is known since it's a built-in field. + let transformedValue; + let coercedToDate; + switch (restKey) { + case 'objectId': + return { key: '_id', value: restValue }; + case 'expiresAt': + transformedValue = transformTopLevelAtom(restValue); + coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue; + return { key: 'expiresAt', value: coercedToDate }; + case '_email_verify_token_expires_at': + transformedValue = transformTopLevelAtom(restValue); + coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue; + return { key: '_email_verify_token_expires_at', value: coercedToDate }; + case '_account_lockout_expires_at': + transformedValue = transformTopLevelAtom(restValue); + coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue; + return { key: '_account_lockout_expires_at', value: coercedToDate }; + case '_perishable_token_expires_at': + transformedValue = transformTopLevelAtom(restValue); + coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue; + return { key: '_perishable_token_expires_at', value: coercedToDate }; + case '_password_changed_at': + transformedValue = transformTopLevelAtom(restValue); + coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue; + return { key: '_password_changed_at', value: coercedToDate }; + case '_failed_login_count': + case '_rperm': + case '_wperm': + case '_email_verify_token': + case '_hashed_password': + case '_perishable_token': + return { key: restKey, value: restValue }; + case 'sessionToken': + return { key: '_session_token', value: restValue }; + default: + // Auth data should have been transformed already + if (restKey.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'can only query on ' + restKey); + } + // Trust that the auth data has been transformed and save it directly + if (restKey.match(/^_auth_data_[a-zA-Z0-9_]+$/)) { + return { key: restKey, value: restValue }; + } + } + //skip straight to transformTopLevelAtom for Bytes, they don't show up in the schema for some reason + if (restValue && restValue.__type !== 'Bytes') { + //Note: We may not know the type of a field here, as the user could be saving (null) to a field + //That never existed before, meaning we can't infer the type. + if (schema.fields[restKey] && schema.fields[restKey].type == 'Pointer' || restValue.__type == 'Pointer') { + restKey = '_p_' + restKey; + } + } + + // Handle atomic values + var value = transformTopLevelAtom(restValue); + if (value !== CannotTransform) { + return { key: restKey, value: value }; + } + + // ACLs are handled before this method is called + // If an ACL key still exists here, something is wrong. + if (restKey === 'ACL') { + throw 'There was a problem transforming an ACL.'; + } + + // Handle arrays + if (restValue instanceof Array) { + value = restValue.map(transformInteriorValue); + return { key: restKey, value: value }; + } + + // Handle normal objects by recursing + if (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"); + } + value = mapValues(restValue, transformInteriorValue); + return { key: restKey, value }; +}; + +const parseObjectToMongoObjectForCreate = (className, restCreate, schema) => { + restCreate = addLegacyACL(restCreate); + const mongoCreate = {}; + for (const restKey in restCreate) { + if (restCreate[restKey] && restCreate[restKey].__type === 'Relation') { + continue; + } + const { key, value } = parseObjectKeyValueToMongoObjectKeyValue(restKey, restCreate[restKey], schema); + if (value !== undefined) { + mongoCreate[key] = value; + } + } + + // Use the legacy mongo format for createdAt and updatedAt + if (mongoCreate.createdAt) { + mongoCreate._created_at = new Date(mongoCreate.createdAt.iso || mongoCreate.createdAt); + delete mongoCreate.createdAt; + } + if (mongoCreate.updatedAt) { + mongoCreate._updated_at = new Date(mongoCreate.updatedAt.iso || mongoCreate.updatedAt); + delete mongoCreate.updatedAt; + } + + return mongoCreate; +}; + +// Main exposed method to help update old objects. +const transformUpdate = (className, restUpdate, parseFormatSchema) => { + const mongoUpdate = {}; + const acl = addLegacyACL(restUpdate); + if (acl._rperm || acl._wperm || acl._acl) { + mongoUpdate.$set = {}; + if (acl._rperm) { + mongoUpdate.$set._rperm = acl._rperm; + } + if (acl._wperm) { + mongoUpdate.$set._wperm = acl._wperm; + } + if (acl._acl) { + mongoUpdate.$set._acl = acl._acl; + } + } + for (var restKey in restUpdate) { + if (restUpdate[restKey] && restUpdate[restKey].__type === 'Relation') { + continue; + } + var out = transformKeyValueForUpdate(className, restKey, restUpdate[restKey], parseFormatSchema); + + // If the output value is an object with any $ keys, it's an + // operator that needs to be lifted onto the top level update + // object. + if (typeof out.value === 'object' && out.value !== null && out.value.__op) { + mongoUpdate[out.value.__op] = mongoUpdate[out.value.__op] || {}; + mongoUpdate[out.value.__op][out.key] = out.value.arg; + } else { + mongoUpdate['$set'] = mongoUpdate['$set'] || {}; + mongoUpdate['$set'][out.key] = out.value; + } + } + + return mongoUpdate; +}; + +// Add the legacy _acl format. +const addLegacyACL = restObject => { + const restObjectCopy = _extends({}, restObject); + const _acl = {}; + + if (restObject._wperm) { + restObject._wperm.forEach(entry => { + _acl[entry] = { w: true }; + }); + restObjectCopy._acl = _acl; + } + + if (restObject._rperm) { + restObject._rperm.forEach(entry => { + if (!(entry in _acl)) { + _acl[entry] = { r: true }; + } else { + _acl[entry].r = true; + } + }); + restObjectCopy._acl = _acl; + } + + return restObjectCopy; +}; + +// A sentinel value that helper transformations return when they +// cannot perform a transformation +function CannotTransform() {} + +const transformInteriorAtom = atom => { + // TODO: check validity harder for the __type-defined types + if (typeof atom === 'object' && atom && !(atom instanceof Date) && atom.__type === 'Pointer') { + return { + __type: 'Pointer', + className: atom.className, + objectId: atom.objectId + }; + } else if (typeof atom === 'function' || typeof atom === 'symbol') { + throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`); + } else if (DateCoder.isValidJSON(atom)) { + return DateCoder.JSONToDatabase(atom); + } else if (BytesCoder.isValidJSON(atom)) { + return BytesCoder.JSONToDatabase(atom); + } else { + return atom; + } +}; + +// Helper function to transform an atom from REST format to Mongo format. +// An atom is anything that can't contain other expressions. So it +// includes things where objects are used to represent other +// datatypes, like pointers and dates, but it does not include objects +// or arrays with generic stuff inside. +// Raises an error if this cannot possibly be valid REST format. +// Returns CannotTransform if it's just not an atom +function transformTopLevelAtom(atom, field) { + switch (typeof atom) { + case 'number': + case 'boolean': + case 'undefined': + return atom; + case 'string': + if (field && field.type === 'Pointer') { + return `${field.targetClass}$${atom}`; + } + return atom; + case 'symbol': + case 'function': + throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`); + case 'object': + if (atom instanceof Date) { + // Technically dates are not rest format, but, it seems pretty + // clear what they should be transformed to, so let's just do it. + return atom; + } + + if (atom === null) { + return atom; + } + + // TODO: check validity harder for the __type-defined types + if (atom.__type == 'Pointer') { + return `${atom.className}$${atom.objectId}`; + } + if (DateCoder.isValidJSON(atom)) { + return DateCoder.JSONToDatabase(atom); + } + if (BytesCoder.isValidJSON(atom)) { + return BytesCoder.JSONToDatabase(atom); + } + if (GeoPointCoder.isValidJSON(atom)) { + return GeoPointCoder.JSONToDatabase(atom); + } + if (PolygonCoder.isValidJSON(atom)) { + return PolygonCoder.JSONToDatabase(atom); + } + if (FileCoder.isValidJSON(atom)) { + return FileCoder.JSONToDatabase(atom); + } + return CannotTransform; + + default: + // I don't think typeof can ever let us get here + throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, `really did not expect value: ${atom}`); + } +} + +function relativeTimeToDate(text, now = new Date()) { + text = text.toLowerCase(); + + let parts = text.split(' '); + + // Filter out whitespace + parts = parts.filter(part => part !== ''); + + const future = parts[0] === 'in'; + const past = parts[parts.length - 1] === 'ago'; + + if (!future && !past && text !== 'now') { + return { status: 'error', info: "Time should either start with 'in' or end with 'ago'" }; + } + + if (future && past) { + return { + status: 'error', + info: "Time cannot have both 'in' and 'ago'" + }; + } + + // strip the 'ago' or 'in' + if (future) { + parts = parts.slice(1); + } else { + // past + parts = parts.slice(0, parts.length - 1); + } + + if (parts.length % 2 !== 0 && text !== 'now') { + return { + status: 'error', + info: 'Invalid time string. Dangling unit or number.' + }; + } + + const pairs = []; + while (parts.length) { + pairs.push([parts.shift(), parts.shift()]); + } + + let seconds = 0; + for (const [num, interval] of pairs) { + const val = Number(num); + if (!Number.isInteger(val)) { + return { + status: 'error', + info: `'${num}' is not an integer.` + }; + } + + switch (interval) { + case 'yr': + case 'yrs': + case 'year': + case 'years': + seconds += val * 31536000; // 365 * 24 * 60 * 60 + break; + + case 'wk': + case 'wks': + case 'week': + case 'weeks': + seconds += val * 604800; // 7 * 24 * 60 * 60 + break; + + case 'd': + case 'day': + case 'days': + seconds += val * 86400; // 24 * 60 * 60 + break; + + case 'hr': + case 'hrs': + case 'hour': + case 'hours': + seconds += val * 3600; // 60 * 60 + break; + + case 'min': + case 'mins': + case 'minute': + case 'minutes': + seconds += val * 60; + break; + + case 'sec': + case 'secs': + case 'second': + case 'seconds': + seconds += val; + break; + + default: + return { + status: 'error', + info: `Invalid interval: '${interval}'` + }; + } + } + + const milliseconds = seconds * 1000; + if (future) { + return { + status: 'success', + info: 'future', + result: new Date(now.valueOf() + milliseconds) + }; + } else if (past) { + return { + status: 'success', + info: 'past', + result: new Date(now.valueOf() - milliseconds) + }; + } else { + return { + status: 'success', + info: 'present', + result: new Date(now.valueOf()) + }; + } +} + +// Transforms a query constraint from REST API format to Mongo format. +// A constraint is something with fields like $lt. +// If it is not a valid constraint but it could be a valid something +// else, return CannotTransform. +// inArray is whether this is an array field. +function transformConstraint(constraint, field) { + const inArray = field && field.type && field.type === 'Array'; + if (typeof constraint !== 'object' || !constraint) { + return CannotTransform; + } + const transformFunction = inArray ? transformInteriorAtom : transformTopLevelAtom; + const transformer = atom => { + const result = transformFunction(atom, field); + if (result === CannotTransform) { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad atom: ${JSON.stringify(atom)}`); + } + return result; + }; + // keys is the constraints in reverse alphabetical order. + // This is a hack so that: + // $regex is handled before $options + // $nearSphere is handled before $maxDistance + var keys = Object.keys(constraint).sort().reverse(); + var answer = {}; + for (var key of keys) { + switch (key) { + case '$lt': + case '$lte': + case '$gt': + case '$gte': + case '$exists': + case '$ne': + case '$eq': + { + const val = constraint[key]; + if (val && typeof val === 'object' && val.$relativeTime) { + if (field && field.type !== 'Date') { + throw new Parse.Error(Parse.Error.INVALID_JSON, '$relativeTime can only be used with Date field'); + } + + switch (key) { + case '$exists': + case '$ne': + case '$eq': + throw new Parse.Error(Parse.Error.INVALID_JSON, '$relativeTime can only be used with the $lt, $lte, $gt, and $gte operators'); + } + + const parserResult = relativeTimeToDate(val.$relativeTime); + if (parserResult.status === 'success') { + answer[key] = parserResult.result; + break; + } + + _logger2.default.info('Error while parsing relative date', parserResult); + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $relativeTime (${key}) value. ${parserResult.info}`); + } + + answer[key] = transformer(val); + break; + } + + case '$in': + case '$nin': + { + const arr = constraint[key]; + if (!(arr instanceof Array)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value'); + } + answer[key] = _lodash2.default.flatMap(arr, value => { + return (atom => { + if (Array.isArray(atom)) { + return value.map(transformer); + } else { + return transformer(atom); + } + })(value); + }); + break; + } + case '$all': + { + const arr = constraint[key]; + if (!(arr instanceof Array)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value'); + } + answer[key] = arr.map(transformInteriorAtom); + break; + } + case '$regex': + var s = constraint[key]; + if (typeof s !== 'string') { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad regex: ' + s); + } + answer[key] = s; + break; + + case '$options': + answer[key] = constraint[key]; + break; + + case '$text': + { + const search = constraint[key].$search; + if (typeof search !== 'object') { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $search, should be object`); + } + if (!search.$term || typeof search.$term !== 'string') { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $term, should be string`); + } else { + answer[key] = { + '$search': search.$term + }; + } + if (search.$language && typeof search.$language !== 'string') { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $language, should be string`); + } else if (search.$language) { + answer[key].$language = search.$language; + } + if (search.$caseSensitive && typeof search.$caseSensitive !== 'boolean') { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $caseSensitive, should be boolean`); + } else if (search.$caseSensitive) { + answer[key].$caseSensitive = search.$caseSensitive; + } + if (search.$diacriticSensitive && typeof search.$diacriticSensitive !== 'boolean') { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $text: $diacriticSensitive, should be boolean`); + } else if (search.$diacriticSensitive) { + answer[key].$diacriticSensitive = search.$diacriticSensitive; + } + break; + } + case '$nearSphere': + var point = constraint[key]; + answer[key] = [point.longitude, point.latitude]; + break; + + case '$maxDistance': + answer[key] = constraint[key]; + break; + + // The SDKs don't seem to use these but they are documented in the + // REST API docs. + case '$maxDistanceInRadians': + answer['$maxDistance'] = constraint[key]; + break; + case '$maxDistanceInMiles': + answer['$maxDistance'] = constraint[key] / 3959; + break; + case '$maxDistanceInKilometers': + answer['$maxDistance'] = constraint[key] / 6371; + break; + + case '$select': + case '$dontSelect': + throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, 'the ' + key + ' constraint is not supported yet'); + + case '$within': + var box = constraint[key]['$box']; + if (!box || box.length != 2) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'malformatted $within arg'); + } + answer[key] = { + '$box': [[box[0].longitude, box[0].latitude], [box[1].longitude, box[1].latitude]] + }; + break; + + case '$geoWithin': + { + const polygon = constraint[key]['$polygon']; + if (!(polygon instanceof Array)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + } + if (polygon.length < 3) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + } + const points = polygon.map(point => { + if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value'); + } else { + Parse.GeoPoint._validate(point.latitude, point.longitude); + } + return [point.longitude, point.latitude]; + }); + answer[key] = { + '$polygon': points + }; + break; + } + case '$geoIntersects': + { + const point = constraint[key]['$point']; + if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoIntersect value; $point should be GeoPoint'); + } else { + Parse.GeoPoint._validate(point.latitude, point.longitude); + } + answer[key] = { + $geometry: { + type: 'Point', + coordinates: [point.longitude, point.latitude] + } + }; + break; + } + default: + if (key.match(/^\$+/)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad constraint: ' + key); + } + return CannotTransform; + } + } + return answer; +} + +// Transforms an update operator from REST format to mongo format. +// To be transformed, the input should have an __op field. +// If flatten is true, this will flatten operators to their static +// data format. For example, an increment of 2 would simply become a +// 2. +// The output for a non-flattened operator is a hash with __op being +// the mongo op, and arg being the argument. +// The output for a flattened operator is just a value. +// Returns undefined if this should be a no-op. + +function transformUpdateOperator({ + __op, + amount, + objects +}, flatten) { + switch (__op) { + case 'Delete': + if (flatten) { + return undefined; + } else { + return { __op: '$unset', arg: '' }; + } + + case 'Increment': + if (typeof amount !== 'number') { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'incrementing must provide a number'); + } + if (flatten) { + return amount; + } else { + return { __op: '$inc', arg: amount }; + } + + case 'Add': + case 'AddUnique': + if (!(objects instanceof Array)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array'); + } + var toAdd = objects.map(transformInteriorAtom); + if (flatten) { + return toAdd; + } else { + var mongoOp = { + Add: '$push', + AddUnique: '$addToSet' + }[__op]; + return { __op: mongoOp, arg: { '$each': toAdd } }; + } + + case 'Remove': + if (!(objects instanceof Array)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to remove must be an array'); + } + var toRemove = objects.map(transformInteriorAtom); + if (flatten) { + return []; + } else { + return { __op: '$pullAll', arg: toRemove }; + } + + default: + throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, `The ${__op} operator is not supported yet.`); + } +} +function mapValues(object, iterator) { + const result = {}; + Object.keys(object).forEach(key => { + result[key] = iterator(object[key]); + }); + return result; +} + +const nestedMongoObjectToNestedParseObject = mongoObject => { + switch (typeof mongoObject) { + case 'string': + case 'number': + case 'boolean': + return mongoObject; + case 'undefined': + case 'symbol': + case 'function': + throw 'bad value in mongoObjectToParseObject'; + case 'object': + if (mongoObject === null) { + return null; + } + if (mongoObject instanceof Array) { + return mongoObject.map(nestedMongoObjectToNestedParseObject); + } + + if (mongoObject instanceof Date) { + return Parse._encode(mongoObject); + } + + if (mongoObject instanceof mongodb.Long) { + return mongoObject.toNumber(); + } + + if (mongoObject instanceof mongodb.Double) { + return mongoObject.value; + } + + if (BytesCoder.isValidDatabaseObject(mongoObject)) { + return BytesCoder.databaseToJSON(mongoObject); + } + + if (mongoObject.hasOwnProperty('__type') && mongoObject.__type == 'Date' && mongoObject.iso instanceof Date) { + mongoObject.iso = mongoObject.iso.toJSON(); + return mongoObject; + } + + return mapValues(mongoObject, nestedMongoObjectToNestedParseObject); + default: + throw 'unknown js type'; + } +}; + +// Converts from a mongo-format object to a REST-format object. +// Does not strip out anything based on a lack of authentication. +const mongoObjectToParseObject = (className, mongoObject, schema) => { + switch (typeof mongoObject) { + case 'string': + case 'number': + case 'boolean': + return mongoObject; + case 'undefined': + case 'symbol': + case 'function': + throw 'bad value in mongoObjectToParseObject'; + case 'object': + { + if (mongoObject === null) { + return null; + } + if (mongoObject instanceof Array) { + return mongoObject.map(nestedMongoObjectToNestedParseObject); + } + + if (mongoObject instanceof Date) { + return Parse._encode(mongoObject); + } + + if (mongoObject instanceof mongodb.Long) { + return mongoObject.toNumber(); + } + + if (mongoObject instanceof mongodb.Double) { + return mongoObject.value; + } + + if (BytesCoder.isValidDatabaseObject(mongoObject)) { + return BytesCoder.databaseToJSON(mongoObject); + } + + const restObject = {}; + if (mongoObject._rperm || mongoObject._wperm) { + restObject._rperm = mongoObject._rperm || []; + restObject._wperm = mongoObject._wperm || []; + delete mongoObject._rperm; + delete mongoObject._wperm; + } + + for (var key in mongoObject) { + switch (key) { + case '_id': + restObject['objectId'] = '' + mongoObject[key]; + break; + case '_hashed_password': + restObject._hashed_password = mongoObject[key]; + break; + case '_acl': + break; + case '_email_verify_token': + case '_perishable_token': + case '_perishable_token_expires_at': + case '_password_changed_at': + case '_tombstone': + case '_email_verify_token_expires_at': + case '_account_lockout_expires_at': + case '_failed_login_count': + case '_password_history': + // Those keys will be deleted if needed in the DB Controller + restObject[key] = mongoObject[key]; + break; + case '_session_token': + restObject['sessionToken'] = mongoObject[key]; + break; + case 'updatedAt': + case '_updated_at': + restObject['updatedAt'] = Parse._encode(new Date(mongoObject[key])).iso; + break; + case 'createdAt': + case '_created_at': + restObject['createdAt'] = Parse._encode(new Date(mongoObject[key])).iso; + break; + case 'expiresAt': + case '_expiresAt': + restObject['expiresAt'] = Parse._encode(new Date(mongoObject[key])); + break; + case 'lastUsed': + case '_last_used': + restObject['lastUsed'] = Parse._encode(new Date(mongoObject[key])).iso; + break; + case 'timesUsed': + case 'times_used': + restObject['timesUsed'] = mongoObject[key]; + break; + default: + // Check other auth data keys + var authDataMatch = key.match(/^_auth_data_([a-zA-Z0-9_]+)$/); + if (authDataMatch) { + var provider = authDataMatch[1]; + restObject['authData'] = restObject['authData'] || {}; + restObject['authData'][provider] = mongoObject[key]; + break; + } + + if (key.indexOf('_p_') == 0) { + var newKey = key.substring(3); + if (!schema.fields[newKey]) { + _logger2.default.info('transform.js', 'Found a pointer column not in the schema, dropping it.', className, newKey); + break; + } + if (schema.fields[newKey].type !== 'Pointer') { + _logger2.default.info('transform.js', 'Found a pointer in a non-pointer column, dropping it.', className, key); + break; + } + if (mongoObject[key] === null) { + break; + } + var objData = mongoObject[key].split('$'); + if (objData[0] !== schema.fields[newKey].targetClass) { + throw 'pointer to incorrect className'; + } + restObject[newKey] = { + __type: 'Pointer', + className: objData[0], + objectId: objData[1] + }; + break; + } else if (key[0] == '_' && key != '__type') { + throw 'bad key in untransform: ' + key; + } else { + var value = mongoObject[key]; + if (schema.fields[key] && schema.fields[key].type === 'File' && FileCoder.isValidDatabaseObject(value)) { + restObject[key] = FileCoder.databaseToJSON(value); + break; + } + if (schema.fields[key] && schema.fields[key].type === 'GeoPoint' && GeoPointCoder.isValidDatabaseObject(value)) { + restObject[key] = GeoPointCoder.databaseToJSON(value); + break; + } + if (schema.fields[key] && schema.fields[key].type === 'Polygon' && PolygonCoder.isValidDatabaseObject(value)) { + restObject[key] = PolygonCoder.databaseToJSON(value); + break; + } + if (schema.fields[key] && schema.fields[key].type === 'Bytes' && BytesCoder.isValidDatabaseObject(value)) { + restObject[key] = BytesCoder.databaseToJSON(value); + break; + } + } + restObject[key] = nestedMongoObjectToNestedParseObject(mongoObject[key]); + } + } + + const relationFieldNames = Object.keys(schema.fields).filter(fieldName => schema.fields[fieldName].type === 'Relation'); + const relationFields = {}; + relationFieldNames.forEach(relationFieldName => { + relationFields[relationFieldName] = { + __type: 'Relation', + className: schema.fields[relationFieldName].targetClass + }; + }); + + return _extends({}, restObject, relationFields); + } + default: + throw 'unknown js type'; + } +}; + +var DateCoder = { + JSONToDatabase(json) { + return new Date(json.iso); + }, + + isValidJSON(value) { + return typeof value === 'object' && value !== null && value.__type === 'Date'; + } +}; + +var BytesCoder = { + base64Pattern: new RegExp("^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"), + isBase64Value(object) { + if (typeof object !== 'string') { + return false; + } + return this.base64Pattern.test(object); + }, + + databaseToJSON(object) { + let value; + if (this.isBase64Value(object)) { + value = object; + } else { + value = object.buffer.toString('base64'); + } + return { + __type: 'Bytes', + base64: value + }; + }, + + isValidDatabaseObject(object) { + return object instanceof mongodb.Binary || this.isBase64Value(object); + }, + + JSONToDatabase(json) { + return new mongodb.Binary(new Buffer(json.base64, 'base64')); + }, + + isValidJSON(value) { + return typeof value === 'object' && value !== null && value.__type === 'Bytes'; + } +}; + +var GeoPointCoder = { + databaseToJSON(object) { + return { + __type: 'GeoPoint', + latitude: object[1], + longitude: object[0] + }; + }, + + isValidDatabaseObject(object) { + return object instanceof Array && object.length == 2; + }, + + JSONToDatabase(json) { + return [json.longitude, json.latitude]; + }, + + isValidJSON(value) { + return typeof value === 'object' && value !== null && value.__type === 'GeoPoint'; + } +}; + +var PolygonCoder = { + databaseToJSON(object) { + return { + __type: 'Polygon', + coordinates: object['coordinates'][0] + }; + }, + + isValidDatabaseObject(object) { + const coords = object.coordinates[0]; + if (object.type !== 'Polygon' || !(coords instanceof Array)) { + return false; + } + for (let i = 0; i < coords.length; i++) { + const point = coords[i]; + if (!GeoPointCoder.isValidDatabaseObject(point)) { + return false; + } + Parse.GeoPoint._validate(parseFloat(point[1]), parseFloat(point[0])); + } + return true; + }, + + JSONToDatabase(json) { + const coords = json.coordinates; + if (coords[0][0] !== coords[coords.length - 1][0] || coords[0][1] !== coords[coords.length - 1][1]) { + coords.push(coords[0]); + } + const unique = coords.filter((item, index, ar) => { + let foundIndex = -1; + for (let i = 0; i < ar.length; i += 1) { + const pt = ar[i]; + if (pt[0] === item[0] && pt[1] === item[1]) { + foundIndex = i; + break; + } + } + return foundIndex === index; + }); + if (unique.length < 3) { + throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'GeoJSON: Loop must have at least 3 different vertices'); + } + return { type: 'Polygon', coordinates: [coords] }; + }, + + isValidJSON(value) { + return typeof value === 'object' && value !== null && value.__type === 'Polygon'; + } +}; + +var FileCoder = { + databaseToJSON(object) { + return { + __type: 'File', + name: object + }; + }, + + isValidDatabaseObject(object) { + return typeof object === 'string'; + }, + + JSONToDatabase(json) { + return json.name; + }, + + isValidJSON(value) { + return typeof value === 'object' && value !== null && value.__type === 'File'; + } +}; + +module.exports = { + transformKey, + parseObjectToMongoObjectForCreate, + transformUpdate, + transformWhere, + mongoObjectToParseObject, + relativeTimeToDate, + transformConstraint +}; \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/PostgresClient.js b/lib/Adapters/Storage/Postgres/PostgresClient.js new file mode 100644 index 0000000000..85429dfa81 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/PostgresClient.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.createClient = createClient; + +const parser = require('./PostgresConfigParser'); + +function createClient(uri, databaseOptions) { + let dbOptions = {}; + databaseOptions = databaseOptions || {}; + + if (uri) { + dbOptions = parser.getDatabaseOptionsFromURI(uri); + } + + for (const key in databaseOptions) { + dbOptions[key] = databaseOptions[key]; + } + + const initOptions = dbOptions.initOptions || {}; + const pgp = require('pg-promise')(initOptions); + const client = pgp(dbOptions); + + if (dbOptions.pgOptions) { + for (const key in dbOptions.pgOptions) { + pgp.pg.defaults[key] = dbOptions.pgOptions[key]; + } + } + + return { client, pgp }; +} \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/PostgresConfigParser.js b/lib/Adapters/Storage/Postgres/PostgresConfigParser.js new file mode 100644 index 0000000000..19a5112a8b --- /dev/null +++ b/lib/Adapters/Storage/Postgres/PostgresConfigParser.js @@ -0,0 +1,46 @@ +'use strict'; + +const url = require('url'); + +function getDatabaseOptionsFromURI(uri) { + const databaseOptions = {}; + + const parsedURI = url.parse(uri); + const queryParams = parseQueryParams(parsedURI.query); + const authParts = parsedURI.auth ? parsedURI.auth.split(':') : []; + + databaseOptions.host = parsedURI.hostname || 'localhost'; + databaseOptions.port = parsedURI.port ? parseInt(parsedURI.port) : 5432; + databaseOptions.database = parsedURI.pathname ? parsedURI.pathname.substr(1) : undefined; + + databaseOptions.user = authParts.length > 0 ? authParts[0] : ''; + databaseOptions.password = authParts.length > 1 ? authParts[1] : ''; + + databaseOptions.ssl = queryParams.ssl && queryParams.ssl.toLowerCase() === 'true' ? true : false; + databaseOptions.binary = queryParams.binary && queryParams.binary.toLowerCase() === 'true' ? true : false; + + databaseOptions.client_encoding = queryParams.client_encoding; + databaseOptions.application_name = queryParams.application_name; + databaseOptions.fallback_application_name = queryParams.fallback_application_name; + + if (queryParams.poolSize) { + databaseOptions.poolSize = parseInt(queryParams.poolSize) || 10; + } + + return databaseOptions; +} + +function parseQueryParams(queryString) { + queryString = queryString || ''; + + return queryString.split('&').reduce((p, c) => { + const parts = c.split('='); + p[decodeURIComponent(parts[0])] = parts.length > 1 ? decodeURIComponent(parts.slice(1).join('=')) : ''; + return p; + }, {}); +} + +module.exports = { + parseQueryParams: parseQueryParams, + getDatabaseOptionsFromURI: getDatabaseOptionsFromURI +}; \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js b/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js new file mode 100644 index 0000000000..29dfa4f670 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js @@ -0,0 +1,1660 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PostgresStorageAdapter = undefined; + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +var _PostgresClient = require('./PostgresClient'); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _sql = require('./sql'); + +var _sql2 = _interopRequireDefault(_sql); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const PostgresRelationDoesNotExistError = '42P01'; +const PostgresDuplicateRelationError = '42P07'; +const PostgresDuplicateColumnError = '42701'; +const PostgresDuplicateObjectError = '42710'; +const PostgresUniqueIndexViolationError = '23505'; +const PostgresTransactionAbortedError = '25P02'; +const logger = require('../../../logger'); + +const debug = function () { + let args = [...arguments]; + args = ['PG: ' + arguments[0]].concat(args.slice(1, args.length)); + const log = logger.getLogger(); + log.debug.apply(log, args); +}; + +const parseTypeToPostgresType = type => { + switch (type.type) { + case 'String': + return 'text'; + case 'Date': + return 'timestamp with time zone'; + case 'Object': + return 'jsonb'; + case 'File': + return 'text'; + case 'Boolean': + return 'boolean'; + case 'Pointer': + return 'char(10)'; + case 'Number': + return 'double precision'; + case 'GeoPoint': + return 'point'; + case 'Bytes': + return 'jsonb'; + case 'Polygon': + return 'polygon'; + case 'Array': + if (type.contents && type.contents.type === 'String') { + return 'text[]'; + } else { + return 'jsonb'; + } + default: + throw `no type for ${JSON.stringify(type)} yet`; + } +}; + +const ParseToPosgresComparator = { + '$gt': '>', + '$lt': '<', + '$gte': '>=', + '$lte': '<=' +}; + +const toPostgresValue = value => { + if (typeof value === 'object') { + if (value.__type === 'Date') { + return value.iso; + } + if (value.__type === 'File') { + return value.name; + } + } + return value; +}; + +const transformValue = value => { + if (typeof value === 'object' && value.__type === 'Pointer') { + return value.objectId; + } + return value; +}; + +// Duplicate from then mongo adapter... +const emptyCLPS = Object.freeze({ + find: {}, + get: {}, + create: {}, + update: {}, + delete: {}, + addField: {} +}); + +const defaultCLPS = Object.freeze({ + find: { '*': true }, + get: { '*': true }, + create: { '*': true }, + update: { '*': true }, + delete: { '*': true }, + addField: { '*': true } +}); + +const toParseSchema = schema => { + if (schema.className === '_User') { + delete schema.fields._hashed_password; + } + if (schema.fields) { + delete schema.fields._wperm; + delete schema.fields._rperm; + } + let clps = defaultCLPS; + if (schema.classLevelPermissions) { + clps = _extends({}, emptyCLPS, schema.classLevelPermissions); + } + let indexes = {}; + if (schema.indexes) { + indexes = _extends({}, schema.indexes); + } + return { + className: schema.className, + fields: schema.fields, + classLevelPermissions: clps, + indexes + }; +}; + +const toPostgresSchema = schema => { + if (!schema) { + return schema; + } + schema.fields = schema.fields || {}; + schema.fields._wperm = { type: 'Array', contents: { type: 'String' } }; + schema.fields._rperm = { type: 'Array', contents: { type: 'String' } }; + if (schema.className === '_User') { + schema.fields._hashed_password = { type: 'String' }; + schema.fields._password_history = { type: 'Array' }; + } + return schema; +}; + +const handleDotFields = object => { + Object.keys(object).forEach(fieldName => { + if (fieldName.indexOf('.') > -1) { + const components = fieldName.split('.'); + const first = components.shift(); + object[first] = object[first] || {}; + let currentObj = object[first]; + let next; + let value = object[fieldName]; + if (value && value.__op === 'Delete') { + value = undefined; + } + /* eslint-disable no-cond-assign */ + while (next = components.shift()) { + /* eslint-enable no-cond-assign */ + currentObj[next] = currentObj[next] || {}; + if (components.length === 0) { + currentObj[next] = value; + } + currentObj = currentObj[next]; + } + delete object[fieldName]; + } + }); + return object; +}; + +const transformDotFieldToComponents = fieldName => { + return fieldName.split('.').map((cmpt, index) => { + if (index === 0) { + return `"${cmpt}"`; + } + return `'${cmpt}'`; + }); +}; + +const transformDotField = fieldName => { + if (fieldName.indexOf('.') === -1) { + return `"${fieldName}"`; + } + const components = transformDotFieldToComponents(fieldName); + let name = components.slice(0, components.length - 1).join('->'); + name += '->>' + components[components.length - 1]; + return name; +}; + +const transformAggregateField = fieldName => { + return fieldName.substr(1); +}; + +const validateKeys = object => { + if (typeof object == 'object') { + for (const key in object) { + if (typeof object[key] == 'object') { + validateKeys(object[key]); + } + + if (key.includes('$') || key.includes('.')) { + throw new _node2.default.Error(_node2.default.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters"); + } + } + } +}; + +// Returns the list of join tables on a schema +const joinTablesForSchema = schema => { + const list = []; + if (schema) { + Object.keys(schema.fields).forEach(field => { + if (schema.fields[field].type === 'Relation') { + list.push(`_Join:${field}:${schema.className}`); + } + }); + } + return list; +}; + +const buildWhereClause = ({ schema, query, index }) => { + const patterns = []; + let values = []; + const sorts = []; + + schema = toPostgresSchema(schema); + for (const fieldName in query) { + const isArrayField = schema.fields && schema.fields[fieldName] && schema.fields[fieldName].type === 'Array'; + const initialPatternsLength = patterns.length; + const fieldValue = query[fieldName]; + + // nothingin the schema, it's gonna blow up + if (!schema.fields[fieldName]) { + // as it won't exist + if (fieldValue && fieldValue.$exists === false) { + continue; + } + } + + if (fieldName.indexOf('.') >= 0) { + let name = transformDotField(fieldName); + if (fieldValue === null) { + patterns.push(`${name} IS NULL`); + } else { + if (fieldValue.$in) { + const inPatterns = []; + name = transformDotFieldToComponents(fieldName).join('->'); + fieldValue.$in.forEach(listElem => { + if (typeof listElem === 'string') { + inPatterns.push(`"${listElem}"`); + } else { + inPatterns.push(`${listElem}`); + } + }); + patterns.push(`(${name})::jsonb @> '[${inPatterns.join(',')}]'::jsonb`); + } else if (fieldValue.$regex) { + // Handle later + } else { + patterns.push(`${name} = '${fieldValue}'`); + } + } + } else if (fieldValue === null || fieldValue === undefined) { + patterns.push(`$${index}:name IS NULL`); + values.push(fieldName); + index += 1; + continue; + } else if (typeof fieldValue === 'string') { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (typeof fieldValue === 'boolean') { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (typeof fieldValue === 'number') { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (fieldName === '$or' || fieldName === '$and') { + const clauses = []; + const clauseValues = []; + fieldValue.forEach(subQuery => { + const clause = buildWhereClause({ schema, query: subQuery, index }); + if (clause.pattern.length > 0) { + clauses.push(clause.pattern); + clauseValues.push(...clause.values); + index += clause.values.length; + } + }); + const orOrAnd = fieldName === '$or' ? ' OR ' : ' AND '; + patterns.push(`(${clauses.join(orOrAnd)})`); + values.push(...clauseValues); + } + + if (fieldValue.$ne !== undefined) { + if (isArrayField) { + fieldValue.$ne = JSON.stringify([fieldValue.$ne]); + patterns.push(`NOT array_contains($${index}:name, $${index + 1})`); + } else { + if (fieldValue.$ne === null) { + patterns.push(`$${index}:name IS NOT NULL`); + values.push(fieldName); + index += 1; + continue; + } else { + // if not null, we need to manually exclude null + patterns.push(`($${index}:name <> $${index + 1} OR $${index}:name IS NULL)`); + } + } + + // TODO: support arrays + values.push(fieldName, fieldValue.$ne); + index += 2; + } + + if (fieldValue.$eq) { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue.$eq); + index += 2; + } + const isInOrNin = Array.isArray(fieldValue.$in) || Array.isArray(fieldValue.$nin); + if (Array.isArray(fieldValue.$in) && isArrayField && schema.fields[fieldName].contents && schema.fields[fieldName].contents.type === 'String') { + const inPatterns = []; + let allowNull = false; + values.push(fieldName); + fieldValue.$in.forEach((listElem, listIndex) => { + if (listElem === null) { + allowNull = true; + } else { + values.push(listElem); + inPatterns.push(`$${index + 1 + listIndex - (allowNull ? 1 : 0)}`); + } + }); + if (allowNull) { + patterns.push(`($${index}:name IS NULL OR $${index}:name && ARRAY[${inPatterns.join(',')}])`); + } else { + patterns.push(`$${index}:name && ARRAY[${inPatterns.join(',')}]`); + } + index = index + 1 + inPatterns.length; + } else if (isInOrNin) { + var createConstraint = (baseArray, notIn) => { + if (baseArray.length > 0) { + const not = notIn ? ' NOT ' : ''; + if (isArrayField) { + patterns.push(`${not} array_contains($${index}:name, $${index + 1})`); + values.push(fieldName, JSON.stringify(baseArray)); + index += 2; + } else { + // Handle Nested Dot Notation Above + if (fieldName.indexOf('.') >= 0) { + return; + } + const inPatterns = []; + values.push(fieldName); + baseArray.forEach((listElem, listIndex) => { + if (listElem !== null) { + values.push(listElem); + inPatterns.push(`$${index + 1 + listIndex}`); + } + }); + patterns.push(`$${index}:name ${not} IN (${inPatterns.join(',')})`); + index = index + 1 + inPatterns.length; + } + } else if (!notIn) { + values.push(fieldName); + patterns.push(`$${index}:name IS NULL`); + index = index + 1; + } + }; + if (fieldValue.$in) { + createConstraint(_lodash2.default.flatMap(fieldValue.$in, elt => elt), false); + } + if (fieldValue.$nin) { + createConstraint(_lodash2.default.flatMap(fieldValue.$nin, elt => elt), true); + } + } + + if (Array.isArray(fieldValue.$all) && isArrayField) { + patterns.push(`array_contains_all($${index}:name, $${index + 1}::jsonb)`); + values.push(fieldName, JSON.stringify(fieldValue.$all)); + index += 2; + } + + if (typeof fieldValue.$exists !== 'undefined') { + if (fieldValue.$exists) { + patterns.push(`$${index}:name IS NOT NULL`); + } else { + patterns.push(`$${index}:name IS NULL`); + } + values.push(fieldName); + index += 1; + } + + if (fieldValue.$text) { + const search = fieldValue.$text.$search; + let language = 'english'; + if (typeof search !== 'object') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $search, should be object`); + } + if (!search.$term || typeof search.$term !== 'string') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $term, should be string`); + } + if (search.$language && typeof search.$language !== 'string') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $language, should be string`); + } else if (search.$language) { + language = search.$language; + } + if (search.$caseSensitive && typeof search.$caseSensitive !== 'boolean') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $caseSensitive, should be boolean`); + } else if (search.$caseSensitive) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $caseSensitive not supported, please use $regex or create a separate lower case column.`); + } + if (search.$diacriticSensitive && typeof search.$diacriticSensitive !== 'boolean') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $diacriticSensitive, should be boolean`); + } else if (search.$diacriticSensitive === false) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $text: $diacriticSensitive - false not supported, install Postgres Unaccent Extension`); + } + patterns.push(`to_tsvector($${index}, $${index + 1}:name) @@ to_tsquery($${index + 2}, $${index + 3})`); + values.push(language, fieldName, language, search.$term); + index += 4; + } + + if (fieldValue.$nearSphere) { + const point = fieldValue.$nearSphere; + const distance = fieldValue.$maxDistance; + const distanceInKM = distance * 6371 * 1000; + patterns.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) <= $${index + 3}`); + sorts.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) ASC`); + values.push(fieldName, point.longitude, point.latitude, distanceInKM); + index += 4; + } + + if (fieldValue.$within && fieldValue.$within.$box) { + const box = fieldValue.$within.$box; + const left = box[0].longitude; + const bottom = box[0].latitude; + const right = box[1].longitude; + const top = box[1].latitude; + + patterns.push(`$${index}:name::point <@ $${index + 1}::box`); + values.push(fieldName, `((${left}, ${bottom}), (${right}, ${top}))`); + index += 2; + } + + if (fieldValue.$geoWithin && fieldValue.$geoWithin.$polygon) { + const polygon = fieldValue.$geoWithin.$polygon; + if (!(polygon instanceof Array)) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + } + if (polygon.length < 3) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + } + const points = polygon.map(point => { + if (typeof point !== 'object' || point.__type !== 'GeoPoint') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value'); + } else { + _node2.default.GeoPoint._validate(point.latitude, point.longitude); + } + return `(${point.longitude}, ${point.latitude})`; + }).join(', '); + + patterns.push(`$${index}:name::point <@ $${index + 1}::polygon`); + values.push(fieldName, `(${points})`); + index += 2; + } + if (fieldValue.$geoIntersects && fieldValue.$geoIntersects.$point) { + const point = fieldValue.$geoIntersects.$point; + if (typeof point !== 'object' || point.__type !== 'GeoPoint') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoIntersect value; $point should be GeoPoint'); + } else { + _node2.default.GeoPoint._validate(point.latitude, point.longitude); + } + patterns.push(`$${index}:name::polygon @> $${index + 1}::point`); + values.push(fieldName, `(${point.longitude}, ${point.latitude})`); + index += 2; + } + + if (fieldValue.$regex) { + let regex = fieldValue.$regex; + let operator = '~'; + const opts = fieldValue.$options; + if (opts) { + if (opts.indexOf('i') >= 0) { + operator = '~*'; + } + if (opts.indexOf('x') >= 0) { + regex = removeWhiteSpace(regex); + } + } + + const name = transformDotField(fieldName); + regex = processRegexPattern(regex); + + patterns.push(`$${index}:raw ${operator} '$${index + 1}:raw'`); + values.push(name, regex); + index += 2; + } + + if (fieldValue.__type === 'Pointer') { + if (isArrayField) { + patterns.push(`array_contains($${index}:name, $${index + 1})`); + values.push(fieldName, JSON.stringify([fieldValue])); + index += 2; + } else { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue.objectId); + index += 2; + } + } + + if (fieldValue.__type === 'Date') { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue.iso); + index += 2; + } + + if (fieldValue.__type === 'GeoPoint') { + patterns.push('$' + index + ':name ~= POINT($' + (index + 1) + ', $' + (index + 2) + ')'); + values.push(fieldName, fieldValue.longitude, fieldValue.latitude); + index += 3; + } + + if (fieldValue.__type === 'Polygon') { + const value = convertPolygonToSQL(fieldValue.coordinates); + patterns.push(`$${index}:name ~= $${index + 1}::polygon`); + values.push(fieldName, value); + index += 2; + } + + Object.keys(ParseToPosgresComparator).forEach(cmp => { + if (fieldValue[cmp]) { + const pgComparator = ParseToPosgresComparator[cmp]; + patterns.push(`$${index}:name ${pgComparator} $${index + 1}`); + values.push(fieldName, toPostgresValue(fieldValue[cmp])); + index += 2; + } + }); + + if (initialPatternsLength === patterns.length) { + throw new _node2.default.Error(_node2.default.Error.OPERATION_FORBIDDEN, `Postgres doesn't support this query type yet ${JSON.stringify(fieldValue)}`); + } + } + values = values.map(transformValue); + return { pattern: patterns.join(' AND '), values, sorts }; +}; + +class PostgresStorageAdapter { + + constructor({ + uri, + collectionPrefix = '', + databaseOptions + }) { + this._collectionPrefix = collectionPrefix; + const { client, pgp } = (0, _PostgresClient.createClient)(uri, databaseOptions); + this._client = client; + this._pgp = pgp; + } + // Private + + + handleShutdown() { + if (!this._client) { + return; + } + this._client.$pool.end(); + } + + _ensureSchemaCollectionExists(conn) { + conn = conn || this._client; + return conn.none('CREATE TABLE IF NOT EXISTS "_SCHEMA" ( "className" varChar(120), "schema" jsonb, "isParseClass" bool, PRIMARY KEY ("className") )').catch(error => { + if (error.code === PostgresDuplicateRelationError || error.code === PostgresUniqueIndexViolationError || error.code === PostgresDuplicateObjectError) { + // Table already exists, must have been created by a different request. Ignore error. + } else { + throw error; + } + }); + } + + classExists(name) { + return this._client.one('SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1)', [name], a => a.exists); + } + + setClassLevelPermissions(className, CLPs) { + return this._ensureSchemaCollectionExists().then(() => { + const values = [className, 'schema', 'classLevelPermissions', JSON.stringify(CLPs)]; + return this._client.none(`UPDATE "_SCHEMA" SET $2:name = json_object_set_key($2:name, $3::text, $4::jsonb) WHERE "className"=$1 `, values); + }); + } + + setIndexesWithSchemaFormat(className, submittedIndexes, existingIndexes = {}, fields, conn) { + conn = conn || this._client; + if (submittedIndexes === undefined) { + return Promise.resolve(); + } + if (Object.keys(existingIndexes).length === 0) { + existingIndexes = { _id_: { _id: 1 } }; + } + const deletedIndexes = []; + const insertedIndexes = []; + Object.keys(submittedIndexes).forEach(name => { + const field = submittedIndexes[name]; + if (existingIndexes[name] && field.__op !== 'Delete') { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`); + } + if (!existingIndexes[name] && field.__op === 'Delete') { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`); + } + if (field.__op === 'Delete') { + deletedIndexes.push(name); + delete existingIndexes[name]; + } else { + Object.keys(field).forEach(key => { + if (!fields.hasOwnProperty(key)) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`); + } + }); + existingIndexes[name] = field; + insertedIndexes.push({ + key: field, + name + }); + } + }); + let insertPromise = Promise.resolve(); + if (insertedIndexes.length > 0) { + insertPromise = this.createIndexes(className, insertedIndexes, conn); + } + let deletePromise = Promise.resolve(); + if (deletedIndexes.length > 0) { + deletePromise = this.dropIndexes(className, deletedIndexes, conn); + } + return conn.task(t => { + const values = [className, 'schema', 'indexes', JSON.stringify(existingIndexes)]; + return t.batch([deletePromise, insertPromise, this._ensureSchemaCollectionExists(t), t.none('UPDATE "_SCHEMA" SET $2:name = json_object_set_key($2:name, $3::text, $4::jsonb) WHERE "className"=$1', values)]); + }); + } + + createClass(className, schema) { + return this._client.tx('create-class', t => { + const q1 = this.createTable(className, schema, t); + const q2 = t.none('INSERT INTO "_SCHEMA" ("className", "schema", "isParseClass") VALUES ($, $, true)', { className, schema }); + const q3 = this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields, t); + + return t.batch([q1, q2, q3]); + }).then(() => { + return toParseSchema(schema); + }).catch(err => { + if (Array.isArray(err.data) && err.data.length > 1 && err.data[0].result.code === PostgresTransactionAbortedError) { + err = err.data[1].result; + } + + if (err.code === PostgresUniqueIndexViolationError && err.detail.includes(className)) { + throw new _node2.default.Error(_node2.default.Error.DUPLICATE_VALUE, `Class ${className} already exists.`); + } + throw err; + }); + } + + // Just create a table, do not insert in schema + createTable(className, schema, conn) { + conn = conn || this._client; + debug('createTable', className, schema); + const valuesArray = []; + const patternsArray = []; + const fields = Object.assign({}, schema.fields); + if (className === '_User') { + fields._email_verify_token_expires_at = { type: 'Date' }; + fields._email_verify_token = { type: 'String' }; + fields._account_lockout_expires_at = { type: 'Date' }; + fields._failed_login_count = { type: 'Number' }; + fields._perishable_token = { type: 'String' }; + fields._perishable_token_expires_at = { type: 'Date' }; + fields._password_changed_at = { type: 'Date' }; + fields._password_history = { type: 'Array' }; + } + let index = 2; + const relations = []; + Object.keys(fields).forEach(fieldName => { + const parseType = fields[fieldName]; + // Skip when it's a relation + // We'll create the tables later + if (parseType.type === 'Relation') { + relations.push(fieldName); + return; + } + if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) { + parseType.contents = { type: 'String' }; + } + valuesArray.push(fieldName); + valuesArray.push(parseTypeToPostgresType(parseType)); + patternsArray.push(`$${index}:name $${index + 1}:raw`); + if (fieldName === 'objectId') { + patternsArray.push(`PRIMARY KEY ($${index}:name)`); + } + index = index + 2; + }); + const qs = `CREATE TABLE IF NOT EXISTS $1:name (${patternsArray.join(',')})`; + const values = [className, ...valuesArray]; + return conn.task(t => { + return this._ensureSchemaCollectionExists(t).then(() => conn.none(qs, values)).catch(error => { + if (error.code === PostgresDuplicateRelationError) { + // Table already exists, must have been created by a different request. Ignore error. + } else { + throw error; + } + }); + }).then(() => { + return conn.tx('create-relation-tables', t => { + const queries = relations.map(fieldName => { + return t.none('CREATE TABLE IF NOT EXISTS $ ("relatedId" varChar(120), "owningId" varChar(120), PRIMARY KEY("relatedId", "owningId") )', { joinTable: `_Join:${fieldName}:${className}` }); + }); + return t.batch(queries); + }); + }); + } + + addFieldIfNotExists(className, fieldName, type) { + // TODO: Must be revised for invalid logic... + debug('addFieldIfNotExists', { className, fieldName, type }); + return this._client.tx('add-field-if-not-exists', t => { + let promise = Promise.resolve(); + if (type.type !== 'Relation') { + promise = t.none('ALTER TABLE $ ADD COLUMN $ $', { + className, + fieldName, + postgresType: parseTypeToPostgresType(type) + }).catch(error => { + if (error.code === PostgresRelationDoesNotExistError) { + return this.createClass(className, { fields: { [fieldName]: type } }); + } else if (error.code === PostgresDuplicateColumnError) { + // Column already exists, created by other request. Carry on to + // See if it's the right type. + } else { + throw error; + } + }); + } else { + promise = t.none('CREATE TABLE IF NOT EXISTS $ ("relatedId" varChar(120), "owningId" varChar(120), PRIMARY KEY("relatedId", "owningId") )', { joinTable: `_Join:${fieldName}:${className}` }); + } + return promise.then(() => { + return t.any('SELECT "schema" FROM "_SCHEMA" WHERE "className" = $ and ("schema"::json->\'fields\'->$) is not null', { className, fieldName }); + }).then(result => { + if (result[0]) { + throw "Attempted to add a field that already exists"; + } else { + const path = `{fields,${fieldName}}`; + return t.none('UPDATE "_SCHEMA" SET "schema"=jsonb_set("schema", $, $) WHERE "className"=$', { path, type, className }); + } + }); + }); + } + + // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.) + // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible. + deleteClass(className) { + const operations = [{ query: `DROP TABLE IF EXISTS $1:name`, values: [className] }, { query: `DELETE FROM "_SCHEMA" WHERE "className" = $1`, values: [className] }]; + return this._client.tx(t => t.none(this._pgp.helpers.concat(operations))).then(() => className.indexOf('_Join:') != 0); // resolves with false when _Join table + } + + // Delete all data known to this adapter. Used for testing. + deleteAllClasses() { + const now = new Date().getTime(); + debug('deleteAllClasses'); + return this._client.any('SELECT * FROM "_SCHEMA"').then(results => { + const joins = results.reduce((list, schema) => { + return list.concat(joinTablesForSchema(schema.schema)); + }, []); + const classes = ['_SCHEMA', '_PushStatus', '_JobStatus', '_JobSchedule', '_Hooks', '_GlobalConfig', '_Audience', ...results.map(result => result.className), ...joins]; + return this._client.tx(t => t.batch(classes.map(className => t.none('DROP TABLE IF EXISTS $', { className })))); + }, error => { + if (error.code === PostgresRelationDoesNotExistError) { + // No _SCHEMA collection. Don't delete anything. + return; + } else { + throw error; + } + }).then(() => { + debug(`deleteAllClasses done in ${new Date().getTime() - now}`); + }); + } + + // Remove the column and all the data. For Relations, the _Join collection is handled + // specially, this function does not delete _Join columns. It should, however, indicate + // that the relation fields does not exist anymore. In mongo, this means removing it from + // the _SCHEMA collection. There should be no actual data in the collection under the same name + // as the relation column, so it's fine to attempt to delete it. If the fields listed to be + // deleted do not exist, this function should return successfully anyways. Checking for + // attempts to delete non-existent fields is the responsibility of Parse Server. + + // This function is not obligated to delete fields atomically. It is given the field + // names in a list so that databases that are capable of deleting fields atomically + // may do so. + + // Returns a Promise. + deleteFields(className, schema, fieldNames) { + debug('deleteFields', className, fieldNames); + return Promise.resolve().then(() => { + fieldNames = fieldNames.reduce((list, fieldName) => { + const field = schema.fields[fieldName]; + if (field.type !== 'Relation') { + list.push(fieldName); + } + delete schema.fields[fieldName]; + return list; + }, []); + + const values = [className, ...fieldNames]; + const columns = fieldNames.map((name, idx) => { + return `$${idx + 2}:name`; + }).join(', DROP COLUMN'); + + const doBatch = t => { + const batch = [t.none('UPDATE "_SCHEMA" SET "schema"=$ WHERE "className"=$', { schema, className })]; + if (values.length > 1) { + batch.push(t.none(`ALTER TABLE $1:name DROP COLUMN ${columns}`, values)); + } + return batch; + }; + return this._client.tx(t => { + return t.batch(doBatch(t)); + }); + }); + } + + // Return a promise for all schemas known to this adapter, in Parse format. In case the + // schemas cannot be retrieved, returns a promise that rejects. Requirements for the + // rejection reason are TBD. + getAllClasses() { + return this._ensureSchemaCollectionExists().then(() => this._client.map('SELECT * FROM "_SCHEMA"', null, row => _extends({ className: row.className }, row.schema))).then(res => res.map(toParseSchema)); + } + + // Return a promise for the schema with the given name, in Parse format. If + // this adapter doesn't know about the schema, return a promise that rejects with + // undefined as the reason. + getClass(className) { + debug('getClass', className); + return this._client.any('SELECT * FROM "_SCHEMA" WHERE "className"=$', { className }).then(result => { + if (result.length === 1) { + return result[0].schema; + } else { + throw undefined; + } + }).then(toParseSchema); + } + + // TODO: remove the mongo format dependency in the return value + createObject(className, schema, object) { + debug('createObject', className, object); + let columnsArray = []; + const valuesArray = []; + schema = toPostgresSchema(schema); + const geoPoints = {}; + + object = handleDotFields(object); + + validateKeys(object); + + Object.keys(object).forEach(fieldName => { + if (object[fieldName] === null) { + return; + } + var authDataMatch = fieldName.match(/^_auth_data_([a-zA-Z0-9_]+)$/); + if (authDataMatch) { + var provider = authDataMatch[1]; + object['authData'] = object['authData'] || {}; + object['authData'][provider] = object[fieldName]; + delete object[fieldName]; + fieldName = 'authData'; + } + + columnsArray.push(fieldName); + if (!schema.fields[fieldName] && className === '_User') { + if (fieldName === '_email_verify_token' || fieldName === '_failed_login_count' || fieldName === '_perishable_token' || fieldName === '_password_history') { + valuesArray.push(object[fieldName]); + } + + if (fieldName === '_email_verify_token_expires_at') { + if (object[fieldName]) { + valuesArray.push(object[fieldName].iso); + } else { + valuesArray.push(null); + } + } + + if (fieldName === '_account_lockout_expires_at' || fieldName === '_perishable_token_expires_at' || fieldName === '_password_changed_at') { + if (object[fieldName]) { + valuesArray.push(object[fieldName].iso); + } else { + valuesArray.push(null); + } + } + return; + } + switch (schema.fields[fieldName].type) { + case 'Date': + if (object[fieldName]) { + valuesArray.push(object[fieldName].iso); + } else { + valuesArray.push(null); + } + break; + case 'Pointer': + valuesArray.push(object[fieldName].objectId); + break; + case 'Array': + if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) { + valuesArray.push(object[fieldName]); + } else { + valuesArray.push(JSON.stringify(object[fieldName])); + } + break; + case 'Object': + case 'Bytes': + case 'String': + case 'Number': + case 'Boolean': + valuesArray.push(object[fieldName]); + break; + case 'File': + valuesArray.push(object[fieldName].name); + break; + case 'Polygon': + { + const value = convertPolygonToSQL(object[fieldName].coordinates); + valuesArray.push(value); + break; + } + case 'GeoPoint': + // pop the point and process later + geoPoints[fieldName] = object[fieldName]; + columnsArray.pop(); + break; + default: + throw `Type ${schema.fields[fieldName].type} not supported yet`; + } + }); + + columnsArray = columnsArray.concat(Object.keys(geoPoints)); + const initialValues = valuesArray.map((val, index) => { + let termination = ''; + const fieldName = columnsArray[index]; + if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) { + termination = '::text[]'; + } else if (schema.fields[fieldName] && schema.fields[fieldName].type === 'Array') { + termination = '::jsonb'; + } + return `$${index + 2 + columnsArray.length}${termination}`; + }); + const geoPointsInjects = Object.keys(geoPoints).map(key => { + const value = geoPoints[key]; + valuesArray.push(value.longitude, value.latitude); + const l = valuesArray.length + columnsArray.length; + return `POINT($${l}, $${l + 1})`; + }); + + const columnsPattern = columnsArray.map((col, index) => `$${index + 2}:name`).join(','); + const valuesPattern = initialValues.concat(geoPointsInjects).join(','); + + const qs = `INSERT INTO $1:name (${columnsPattern}) VALUES (${valuesPattern})`; + const values = [className, ...columnsArray, ...valuesArray]; + debug(qs, values); + return this._client.none(qs, values).then(() => ({ ops: [object] })).catch(error => { + if (error.code === PostgresUniqueIndexViolationError) { + const err = new _node2.default.Error(_node2.default.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided'); + err.underlyingError = error; + if (error.constraint) { + const matches = error.constraint.match(/unique_([a-zA-Z]+)/); + if (matches && Array.isArray(matches)) { + err.userInfo = { duplicated_field: matches[1] }; + } + } + throw err; + } else { + throw error; + } + }); + } + + // Remove all objects that match the given Parse Query. + // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined. + // If there is some other error, reject with INTERNAL_SERVER_ERROR. + deleteObjectsByQuery(className, schema, query) { + debug('deleteObjectsByQuery', className, query); + const values = [className]; + const index = 2; + const where = buildWhereClause({ schema, index, query }); + values.push(...where.values); + if (Object.keys(query).length === 0) { + where.pattern = 'TRUE'; + } + const qs = `WITH deleted AS (DELETE FROM $1:name WHERE ${where.pattern} RETURNING *) SELECT count(*) FROM deleted`; + debug(qs, values); + return this._client.one(qs, values, a => +a.count).then(count => { + if (count === 0) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Object not found.'); + } else { + return count; + } + }).catch(error => { + if (error.code === PostgresRelationDoesNotExistError) { + // Don't delete anything if doesn't exist + } else { + throw error; + } + }); + } + // Return value not currently well specified. + findOneAndUpdate(className, schema, query, update) { + debug('findOneAndUpdate', className, query, update); + return this.updateObjectsByQuery(className, schema, query, update).then(val => val[0]); + } + + // Apply the update to all objects that match the given Parse Query. + updateObjectsByQuery(className, schema, query, update) { + debug('updateObjectsByQuery', className, query, update); + const updatePatterns = []; + const values = [className]; + let index = 2; + schema = toPostgresSchema(schema); + + const originalUpdate = _extends({}, update); + update = handleDotFields(update); + // Resolve authData first, + // So we don't end up with multiple key updates + for (const fieldName in update) { + const authDataMatch = fieldName.match(/^_auth_data_([a-zA-Z0-9_]+)$/); + if (authDataMatch) { + var provider = authDataMatch[1]; + const value = update[fieldName]; + delete update[fieldName]; + update['authData'] = update['authData'] || {}; + update['authData'][provider] = value; + } + } + + for (const fieldName in update) { + const fieldValue = update[fieldName]; + if (fieldValue === null) { + updatePatterns.push(`$${index}:name = NULL`); + values.push(fieldName); + index += 1; + } else if (fieldName == 'authData') { + // This recursively sets the json_object + // Only 1 level deep + const generate = (jsonb, key, value) => { + return `json_object_set_key(COALESCE(${jsonb}, '{}'::jsonb), ${key}, ${value})::jsonb`; + }; + const lastKey = `$${index}:name`; + const fieldNameIndex = index; + index += 1; + values.push(fieldName); + const update = Object.keys(fieldValue).reduce((lastKey, key) => { + const str = generate(lastKey, `$${index}::text`, `$${index + 1}::jsonb`); + index += 2; + let value = fieldValue[key]; + if (value) { + if (value.__op === 'Delete') { + value = null; + } else { + value = JSON.stringify(value); + } + } + values.push(key, value); + return str; + }, lastKey); + updatePatterns.push(`$${fieldNameIndex}:name = ${update}`); + } else if (fieldValue.__op === 'Increment') { + updatePatterns.push(`$${index}:name = COALESCE($${index}:name, 0) + $${index + 1}`); + values.push(fieldName, fieldValue.amount); + index += 2; + } else if (fieldValue.__op === 'Add') { + updatePatterns.push(`$${index}:name = array_add(COALESCE($${index}:name, '[]'::jsonb), $${index + 1}::jsonb)`); + values.push(fieldName, JSON.stringify(fieldValue.objects)); + index += 2; + } else if (fieldValue.__op === 'Delete') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, null); + index += 2; + } else if (fieldValue.__op === 'Remove') { + updatePatterns.push(`$${index}:name = array_remove(COALESCE($${index}:name, '[]'::jsonb), $${index + 1}::jsonb)`); + values.push(fieldName, JSON.stringify(fieldValue.objects)); + index += 2; + } else if (fieldValue.__op === 'AddUnique') { + updatePatterns.push(`$${index}:name = array_add_unique(COALESCE($${index}:name, '[]'::jsonb), $${index + 1}::jsonb)`); + values.push(fieldName, JSON.stringify(fieldValue.objects)); + index += 2; + } else if (fieldName === 'updatedAt') { + //TODO: stop special casing this. It should check for __type === 'Date' and use .iso + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (typeof fieldValue === 'string') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (typeof fieldValue === 'boolean') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (fieldValue.__type === 'Pointer') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue.objectId); + index += 2; + } else if (fieldValue.__type === 'Date') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, toPostgresValue(fieldValue)); + index += 2; + } else if (fieldValue instanceof Date) { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (fieldValue.__type === 'File') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, toPostgresValue(fieldValue)); + index += 2; + } else if (fieldValue.__type === 'GeoPoint') { + updatePatterns.push(`$${index}:name = POINT($${index + 1}, $${index + 2})`); + values.push(fieldName, fieldValue.longitude, fieldValue.latitude); + index += 3; + } else if (fieldValue.__type === 'Polygon') { + const value = convertPolygonToSQL(fieldValue.coordinates); + updatePatterns.push(`$${index}:name = $${index + 1}::polygon`); + values.push(fieldName, value); + index += 2; + } else if (fieldValue.__type === 'Relation') { + // noop + } else if (typeof fieldValue === 'number') { + updatePatterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue); + index += 2; + } else if (typeof fieldValue === 'object' && schema.fields[fieldName] && schema.fields[fieldName].type === 'Object') { + // Gather keys to increment + const keysToIncrement = Object.keys(originalUpdate).filter(k => { + // choose top level fields that have a delete operation set + return originalUpdate[k].__op === 'Increment' && k.split('.').length === 2 && k.split(".")[0] === fieldName; + }).map(k => k.split('.')[1]); + + let incrementPatterns = ''; + if (keysToIncrement.length > 0) { + incrementPatterns = ' || ' + keysToIncrement.map(c => { + const amount = fieldValue[c].amount; + return `CONCAT('{"${c}":', COALESCE($${index}:name->>'${c}','0')::int + ${amount}, '}')::jsonb`; + }).join(' || '); + // Strip the keys + keysToIncrement.forEach(key => { + delete fieldValue[key]; + }); + } + + const keysToDelete = Object.keys(originalUpdate).filter(k => { + // choose top level fields that have a delete operation set + return originalUpdate[k].__op === 'Delete' && k.split('.').length === 2 && k.split(".")[0] === fieldName; + }).map(k => k.split('.')[1]); + + const deletePatterns = keysToDelete.reduce((p, c, i) => { + return p + ` - '$${index + 1 + i}:value'`; + }, ''); + + updatePatterns.push(`$${index}:name = ( COALESCE($${index}:name, '{}'::jsonb) ${deletePatterns} ${incrementPatterns} || $${index + 1 + keysToDelete.length}::jsonb )`); + + values.push(fieldName, ...keysToDelete, JSON.stringify(fieldValue)); + index += 2 + keysToDelete.length; + } else if (Array.isArray(fieldValue) && schema.fields[fieldName] && schema.fields[fieldName].type === 'Array') { + const expectedType = parseTypeToPostgresType(schema.fields[fieldName]); + if (expectedType === 'text[]') { + updatePatterns.push(`$${index}:name = $${index + 1}::text[]`); + } else { + let type = 'text'; + for (const elt of fieldValue) { + if (typeof elt == 'object') { + type = 'json'; + break; + } + } + updatePatterns.push(`$${index}:name = array_to_json($${index + 1}::${type}[])::jsonb`); + } + values.push(fieldName, fieldValue); + index += 2; + } else { + debug('Not supported update', fieldName, fieldValue); + return Promise.reject(new _node2.default.Error(_node2.default.Error.OPERATION_FORBIDDEN, `Postgres doesn't support update ${JSON.stringify(fieldValue)} yet`)); + } + } + + const where = buildWhereClause({ schema, index, query }); + values.push(...where.values); + + const whereClause = where.pattern.length > 0 ? `WHERE ${where.pattern}` : ''; + const qs = `UPDATE $1:name SET ${updatePatterns.join(',')} ${whereClause} RETURNING *`; + debug('update: ', qs, values); + return this._client.any(qs, values); + } + + // Hopefully, we can get rid of this. It's only used for config and hooks. + upsertOneObject(className, schema, query, update) { + debug('upsertOneObject', { className, query, update }); + const createValue = Object.assign({}, query, update); + return this.createObject(className, schema, createValue).catch(err => { + // ignore duplicate value errors as it's upsert + if (err.code === _node2.default.Error.DUPLICATE_VALUE) { + return this.findOneAndUpdate(className, schema, query, update); + } + throw err; + }); + } + + find(className, schema, query, { skip, limit, sort, keys }) { + debug('find', className, query, { skip, limit, sort, keys }); + const hasLimit = limit !== undefined; + const hasSkip = skip !== undefined; + let values = [className]; + const where = buildWhereClause({ schema, query, index: 2 }); + values.push(...where.values); + + const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : ''; + const limitPattern = hasLimit ? `LIMIT $${values.length + 1}` : ''; + if (hasLimit) { + values.push(limit); + } + const skipPattern = hasSkip ? `OFFSET $${values.length + 1}` : ''; + if (hasSkip) { + values.push(skip); + } + + let sortPattern = ''; + if (sort) { + const sorting = Object.keys(sort).map(key => { + // Using $idx pattern gives: non-integer constant in ORDER BY + if (sort[key] === 1) { + return `"${key}" ASC`; + } + return `"${key}" DESC`; + }).join(','); + sortPattern = sort !== undefined && Object.keys(sort).length > 0 ? `ORDER BY ${sorting}` : ''; + } + if (where.sorts && Object.keys(where.sorts).length > 0) { + sortPattern = `ORDER BY ${where.sorts.join(',')}`; + } + + let columns = '*'; + if (keys) { + // Exclude empty keys + keys = keys.filter(key => { + return key.length > 0; + }); + columns = keys.map((key, index) => { + if (key === '$score') { + return `ts_rank_cd(to_tsvector($${2}, $${3}:name), to_tsquery($${4}, $${5}), 32) as score`; + } + return `$${index + values.length + 1}:name`; + }).join(','); + values = values.concat(keys); + } + + const qs = `SELECT ${columns} FROM $1:name ${wherePattern} ${sortPattern} ${limitPattern} ${skipPattern}`; + debug(qs, values); + return this._client.any(qs, values).catch(err => { + // Query on non existing table, don't crash + if (err.code === PostgresRelationDoesNotExistError) { + return []; + } + return Promise.reject(err); + }).then(results => results.map(object => this.postgresObjectToParseObject(className, object, schema))); + } + + // Converts from a postgres-format object to a REST-format object. + // Does not strip out anything based on a lack of authentication. + postgresObjectToParseObject(className, object, schema) { + Object.keys(schema.fields).forEach(fieldName => { + if (schema.fields[fieldName].type === 'Pointer' && object[fieldName]) { + object[fieldName] = { objectId: object[fieldName], __type: 'Pointer', className: schema.fields[fieldName].targetClass }; + } + if (schema.fields[fieldName].type === 'Relation') { + object[fieldName] = { + __type: "Relation", + className: schema.fields[fieldName].targetClass + }; + } + if (object[fieldName] && schema.fields[fieldName].type === 'GeoPoint') { + object[fieldName] = { + __type: "GeoPoint", + latitude: object[fieldName].y, + longitude: object[fieldName].x + }; + } + if (object[fieldName] && schema.fields[fieldName].type === 'Polygon') { + let coords = object[fieldName]; + coords = coords.substr(2, coords.length - 4).split('),('); + coords = coords.map(point => { + return [parseFloat(point.split(',')[1]), parseFloat(point.split(',')[0])]; + }); + object[fieldName] = { + __type: "Polygon", + coordinates: coords + }; + } + if (object[fieldName] && schema.fields[fieldName].type === 'File') { + object[fieldName] = { + __type: 'File', + name: object[fieldName] + }; + } + }); + //TODO: remove this reliance on the mongo format. DB adapter shouldn't know there is a difference between created at and any other date field. + if (object.createdAt) { + object.createdAt = object.createdAt.toISOString(); + } + if (object.updatedAt) { + object.updatedAt = object.updatedAt.toISOString(); + } + if (object.expiresAt) { + object.expiresAt = { __type: 'Date', iso: object.expiresAt.toISOString() }; + } + if (object._email_verify_token_expires_at) { + object._email_verify_token_expires_at = { __type: 'Date', iso: object._email_verify_token_expires_at.toISOString() }; + } + if (object._account_lockout_expires_at) { + object._account_lockout_expires_at = { __type: 'Date', iso: object._account_lockout_expires_at.toISOString() }; + } + if (object._perishable_token_expires_at) { + object._perishable_token_expires_at = { __type: 'Date', iso: object._perishable_token_expires_at.toISOString() }; + } + if (object._password_changed_at) { + object._password_changed_at = { __type: 'Date', iso: object._password_changed_at.toISOString() }; + } + + for (const fieldName in object) { + if (object[fieldName] === null) { + delete object[fieldName]; + } + if (object[fieldName] instanceof Date) { + object[fieldName] = { __type: 'Date', iso: object[fieldName].toISOString() }; + } + } + + return object; + } + + // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't + // currently know which fields are nullable and which aren't, we ignore that criteria. + // As such, we shouldn't expose this function to users of parse until we have an out-of-band + // Way of determining if a field is nullable. Undefined doesn't count against uniqueness, + // which is why we use sparse indexes. + ensureUniqueness(className, schema, fieldNames) { + // Use the same name for every ensureUniqueness attempt, because postgres + // Will happily create the same index with multiple names. + const constraintName = `unique_${fieldNames.sort().join('_')}`; + const constraintPatterns = fieldNames.map((fieldName, index) => `$${index + 3}:name`); + const qs = `ALTER TABLE $1:name ADD CONSTRAINT $2:name UNIQUE (${constraintPatterns.join(',')})`; + return this._client.none(qs, [className, constraintName, ...fieldNames]).catch(error => { + if (error.code === PostgresDuplicateRelationError && error.message.includes(constraintName)) { + // Index already exists. Ignore error. + } else if (error.code === PostgresUniqueIndexViolationError && error.message.includes(constraintName)) { + // Cast the error into the proper parse error + throw new _node2.default.Error(_node2.default.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided'); + } else { + throw error; + } + }); + } + + // Executes a count. + count(className, schema, query) { + debug('count', className, query); + const values = [className]; + const where = buildWhereClause({ schema, query, index: 2 }); + values.push(...where.values); + + const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : ''; + const qs = `SELECT count(*) FROM $1:name ${wherePattern}`; + return this._client.one(qs, values, a => +a.count).catch(err => { + if (err.code === PostgresRelationDoesNotExistError) { + return 0; + } + throw err; + }); + } + + distinct(className, schema, query, fieldName) { + debug('distinct', className, query); + let field = fieldName; + let column = fieldName; + if (fieldName.indexOf('.') >= 0) { + field = transformDotFieldToComponents(fieldName).join('->'); + column = fieldName.split('.')[0]; + } + const isArrayField = schema.fields && schema.fields[fieldName] && schema.fields[fieldName].type === 'Array'; + const values = [field, column, className]; + const where = buildWhereClause({ schema, query, index: 4 }); + values.push(...where.values); + + const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : ''; + let qs = `SELECT DISTINCT ON ($1:raw) $2:raw FROM $3:name ${wherePattern}`; + if (isArrayField) { + qs = `SELECT distinct jsonb_array_elements($1:raw) as $2:raw FROM $3:name ${wherePattern}`; + } + debug(qs, values); + return this._client.any(qs, values).catch(() => []).then(results => { + if (fieldName.indexOf('.') === -1) { + return results.map(object => object[field]); + } + const child = fieldName.split('.')[1]; + return results.map(object => object[column][child]); + }).then(results => results.map(object => this.postgresObjectToParseObject(className, object, schema))); + } + + aggregate(className, schema, pipeline) { + debug('aggregate', className, pipeline); + const values = [className]; + let columns = []; + let countField = null; + let wherePattern = ''; + let limitPattern = ''; + let skipPattern = ''; + let sortPattern = ''; + let groupPattern = ''; + for (let i = 0; i < pipeline.length; i += 1) { + const stage = pipeline[i]; + if (stage.$group) { + for (const field in stage.$group) { + const value = stage.$group[field]; + if (value === null || value === undefined) { + continue; + } + if (field === '_id') { + columns.push(`${transformAggregateField(value)} AS "objectId"`); + groupPattern = `GROUP BY ${transformAggregateField(value)}`; + continue; + } + if (value.$sum) { + if (typeof value.$sum === 'string') { + columns.push(`SUM(${transformAggregateField(value.$sum)}) AS "${field}"`); + } else { + countField = field; + columns.push(`COUNT(*) AS "${field}"`); + } + } + if (value.$max) { + columns.push(`MAX(${transformAggregateField(value.$max)}) AS "${field}"`); + } + if (value.$min) { + columns.push(`MIN(${transformAggregateField(value.$min)}) AS "${field}"`); + } + if (value.$avg) { + columns.push(`AVG(${transformAggregateField(value.$avg)}) AS "${field}"`); + } + } + columns.join(','); + } else { + columns.push('*'); + } + if (stage.$project) { + if (columns.includes('*')) { + columns = []; + } + for (const field in stage.$project) { + const value = stage.$project[field]; + if (value === 1 || value === true) { + columns.push(field); + } + } + } + if (stage.$match) { + const patterns = []; + for (const field in stage.$match) { + const value = stage.$match[field]; + Object.keys(ParseToPosgresComparator).forEach(cmp => { + if (value[cmp]) { + const pgComparator = ParseToPosgresComparator[cmp]; + patterns.push(`${field} ${pgComparator} ${value[cmp]}`); + } + }); + } + wherePattern = patterns.length > 0 ? `WHERE ${patterns.join(' ')}` : ''; + } + if (stage.$limit) { + limitPattern = `LIMIT ${stage.$limit}`; + } + if (stage.$skip) { + skipPattern = `OFFSET ${stage.$skip}`; + } + if (stage.$sort) { + const sort = stage.$sort; + const sorting = Object.keys(sort).map(key => { + if (sort[key] === 1) { + return `"${key}" ASC`; + } + return `"${key}" DESC`; + }).join(','); + sortPattern = sort !== undefined && Object.keys(sort).length > 0 ? `ORDER BY ${sorting}` : ''; + } + } + + const qs = `SELECT ${columns} FROM $1:name ${wherePattern} ${sortPattern} ${limitPattern} ${skipPattern} ${groupPattern}`; + debug(qs, values); + return this._client.any(qs, values).then(results => results.map(object => this.postgresObjectToParseObject(className, object, schema))).then(results => { + if (countField) { + results[0][countField] = parseInt(results[0][countField], 10); + } + results.forEach(result => { + if (!result.hasOwnProperty('objectId')) { + result.objectId = null; + } + }); + return results; + }); + } + + performInitialization({ VolatileClassesSchemas }) { + debug('performInitialization'); + const promises = VolatileClassesSchemas.map(schema => { + return this.createTable(schema.className, schema).catch(err => { + if (err.code === PostgresDuplicateRelationError || err.code === _node2.default.Error.INVALID_CLASS_NAME) { + return Promise.resolve(); + } + throw err; + }); + }); + return Promise.all(promises).then(() => { + return this._client.tx(t => { + return t.batch([t.none(_sql2.default.misc.jsonObjectSetKeys), t.none(_sql2.default.array.add), t.none(_sql2.default.array.addUnique), t.none(_sql2.default.array.remove), t.none(_sql2.default.array.containsAll), t.none(_sql2.default.array.contains)]); + }); + }).then(data => { + debug(`initializationDone in ${data.duration}`); + }).catch(error => { + /* eslint-disable no-console */ + console.error(error); + }); + } + + createIndexes(className, indexes, conn) { + return (conn || this._client).tx(t => t.batch(indexes.map(i => { + return t.none('CREATE INDEX $1:name ON $2:name ($3:name)', [i.name, className, i.key]); + }))); + } + + dropIndexes(className, indexes, conn) { + return (conn || this._client).tx(t => t.batch(indexes.map(i => t.none('DROP INDEX $1:name', i)))); + } + + getIndexes(className) { + const qs = 'SELECT * FROM pg_indexes WHERE tablename = ${className}'; + return this._client.any(qs, { className }); + } + + updateSchemaWithIndexes() { + return Promise.resolve(); + } +} + +exports.PostgresStorageAdapter = PostgresStorageAdapter; +function convertPolygonToSQL(polygon) { + if (polygon.length < 3) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `Polygon must have at least 3 values`); + } + if (polygon[0][0] !== polygon[polygon.length - 1][0] || polygon[0][1] !== polygon[polygon.length - 1][1]) { + polygon.push(polygon[0]); + } + const unique = polygon.filter((item, index, ar) => { + let foundIndex = -1; + for (let i = 0; i < ar.length; i += 1) { + const pt = ar[i]; + if (pt[0] === item[0] && pt[1] === item[1]) { + foundIndex = i; + break; + } + } + return foundIndex === index; + }); + if (unique.length < 3) { + throw new _node2.default.Error(_node2.default.Error.INTERNAL_SERVER_ERROR, 'GeoJSON: Loop must have at least 3 different vertices'); + } + const points = polygon.map(point => { + _node2.default.GeoPoint._validate(parseFloat(point[1]), parseFloat(point[0])); + return `(${point[1]}, ${point[0]})`; + }).join(', '); + return `(${points})`; +} + +function removeWhiteSpace(regex) { + if (!regex.endsWith('\n')) { + regex += '\n'; + } + + // remove non escaped comments + return regex.replace(/([^\\])#.*\n/gmi, '$1') + // remove lines starting with a comment + .replace(/^#.*\n/gmi, '') + // remove non escaped whitespace + .replace(/([^\\])\s+/gmi, '$1') + // remove whitespace at the beginning of a line + .replace(/^\s+/, '').trim(); +} + +function processRegexPattern(s) { + if (s && s.startsWith('^')) { + // regex for startsWith + return '^' + literalizeRegexPart(s.slice(1)); + } else if (s && s.endsWith('$')) { + // regex for endsWith + return literalizeRegexPart(s.slice(0, s.length - 1)) + '$'; + } + + // regex for contains + return literalizeRegexPart(s); +} + +function createLiteralRegex(remaining) { + return remaining.split('').map(c => { + if (c.match(/[0-9a-zA-Z]/) !== null) { + // don't escape alphanumeric characters + return c; + } + // escape everything else (single quotes with single quotes, everything else with a backslash) + return c === `'` ? `''` : `\\${c}`; + }).join(''); +} + +function literalizeRegexPart(s) { + const matcher1 = /\\Q((?!\\E).*)\\E$/; + const result1 = s.match(matcher1); + if (result1 && result1.length > 1 && result1.index > -1) { + // process regex that has a beginning and an end specified for the literal text + const prefix = s.substr(0, result1.index); + const remaining = result1[1]; + + return literalizeRegexPart(prefix) + createLiteralRegex(remaining); + } + + // process regex that has a beginning specified for the literal text + const matcher2 = /\\Q((?!\\E).*)$/; + const result2 = s.match(matcher2); + if (result2 && result2.length > 1 && result2.index > -1) { + const prefix = s.substr(0, result2.index); + const remaining = result2[1]; + + return literalizeRegexPart(prefix) + createLiteralRegex(remaining); + } + + // remove all instances of \Q and \E from the remaining text & escape single quotes + return s.replace(/([^\\])(\\E)/, '$1').replace(/([^\\])(\\Q)/, '$1').replace(/^\\E/, '').replace(/^\\Q/, '').replace(/([^'])'/, `$1''`).replace(/^'([^'])/, `''$1`); +} + +exports.default = PostgresStorageAdapter; + +module.exports = PostgresStorageAdapter; // Required for tests \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/sql/array/add-unique.sql b/lib/Adapters/Storage/Postgres/sql/array/add-unique.sql new file mode 100644 index 0000000000..aad90d45f5 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/array/add-unique.sql @@ -0,0 +1,11 @@ +CREATE OR REPLACE FUNCTION array_add_unique( + "array" jsonb, + "values" jsonb +) + RETURNS jsonb + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT array_to_json(ARRAY(SELECT DISTINCT unnest(ARRAY(SELECT DISTINCT jsonb_array_elements("array")) || ARRAY(SELECT DISTINCT jsonb_array_elements("values")))))::jsonb; +$function$; diff --git a/lib/Adapters/Storage/Postgres/sql/array/add.sql b/lib/Adapters/Storage/Postgres/sql/array/add.sql new file mode 100644 index 0000000000..a0b5859908 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/array/add.sql @@ -0,0 +1,11 @@ +CREATE OR REPLACE FUNCTION array_add( + "array" jsonb, + "values" jsonb +) + RETURNS jsonb + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT array_to_json(ARRAY(SELECT unnest(ARRAY(SELECT DISTINCT jsonb_array_elements("array")) || ARRAY(SELECT jsonb_array_elements("values")))))::jsonb; +$function$; diff --git a/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql b/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql new file mode 100644 index 0000000000..24355bc732 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql @@ -0,0 +1,11 @@ +CREATE OR REPLACE FUNCTION array_contains_all( + "array" jsonb, + "values" jsonb +) + RETURNS boolean + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements("array") as elt WHERE elt IN (SELECT jsonb_array_elements("values"))) as RES; +$function$; diff --git a/lib/Adapters/Storage/Postgres/sql/array/contains.sql b/lib/Adapters/Storage/Postgres/sql/array/contains.sql new file mode 100644 index 0000000000..f7c458782e --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/array/contains.sql @@ -0,0 +1,11 @@ +CREATE OR REPLACE FUNCTION array_contains( + "array" jsonb, + "values" jsonb +) + RETURNS boolean + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT RES.CNT >= 1 FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements("array") as elt WHERE elt IN (SELECT jsonb_array_elements("values"))) as RES; +$function$; diff --git a/lib/Adapters/Storage/Postgres/sql/array/remove.sql b/lib/Adapters/Storage/Postgres/sql/array/remove.sql new file mode 100644 index 0000000000..52895d2f46 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/array/remove.sql @@ -0,0 +1,11 @@ +CREATE OR REPLACE FUNCTION array_remove( + "array" jsonb, + "values" jsonb +) + RETURNS jsonb + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT array_to_json(ARRAY(SELECT * FROM jsonb_array_elements("array") as elt WHERE elt NOT IN (SELECT * FROM (SELECT jsonb_array_elements("values")) AS sub)))::jsonb; +$function$; diff --git a/lib/Adapters/Storage/Postgres/sql/index.js b/lib/Adapters/Storage/Postgres/sql/index.js new file mode 100644 index 0000000000..c1b31b93ac --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/index.js @@ -0,0 +1,32 @@ +'use strict'; + +var QueryFile = require('pg-promise').QueryFile; +var path = require('path'); + +module.exports = { + array: { + add: sql('array/add.sql'), + addUnique: sql('array/add-unique.sql'), + contains: sql('array/contains.sql'), + containsAll: sql('array/contains-all.sql'), + remove: sql('array/remove.sql') + }, + misc: { + jsonObjectSetKeys: sql('misc/json-object-set-keys.sql') + } +}; + +/////////////////////////////////////////////// +// Helper for linking to external query files; +function sql(file) { + + var fullPath = path.join(__dirname, file); // generating full path; + + var qf = new QueryFile(fullPath, { minify: true }); + + if (qf.error) { + throw qf.error; + } + + return qf; +} \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/sql/misc/json-object-set-keys.sql b/lib/Adapters/Storage/Postgres/sql/misc/json-object-set-keys.sql new file mode 100644 index 0000000000..eb28b36928 --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/misc/json-object-set-keys.sql @@ -0,0 +1,19 @@ +-- Function to set a key on a nested JSON document + +CREATE OR REPLACE FUNCTION json_object_set_key( + "json" jsonb, + key_to_set TEXT, + value_to_set anyelement +) + RETURNS jsonb + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ +SELECT concat('{', string_agg(to_json("key") || ':' || "value", ','), '}')::jsonb + FROM (SELECT * + FROM jsonb_each("json") + WHERE key <> key_to_set + UNION ALL + SELECT key_to_set, to_json("value_to_set")::jsonb) AS fields +$function$; diff --git a/lib/Auth.js b/lib/Auth.js new file mode 100644 index 0000000000..2520d1dba1 --- /dev/null +++ b/lib/Auth.js @@ -0,0 +1,221 @@ +'use strict'; + +var Parse = require('parse/node').Parse; +var RestQuery = require('./RestQuery'); + +// An Auth object tells you who is requesting something and whether +// the master key was used. +// userObject is a Parse.User and can be null if there's no user. +function Auth({ config, isMaster = false, isReadOnly = false, user, installationId } = {}) { + this.config = config; + this.installationId = installationId; + this.isMaster = isMaster; + this.user = user; + this.isReadOnly = isReadOnly; + + // Assuming a users roles won't change during a single request, we'll + // only load them once. + this.userRoles = []; + this.fetchedRoles = false; + this.rolePromise = null; +} + +// Whether this auth could possibly modify the given user id. +// It still could be forbidden via ACLs even if this returns true. +Auth.prototype.couldUpdateUserId = function (userId) { + if (this.isMaster) { + return true; + } + if (this.user && this.user.id === userId) { + return true; + } + return false; +}; + +// A helper to get a master-level Auth object +function master(config) { + return new Auth({ config, isMaster: true }); +} + +// A helper to get a master-level Auth object +function readOnly(config) { + return new Auth({ config, isMaster: true, isReadOnly: true }); +} + +// A helper to get a nobody-level Auth object +function nobody(config) { + return new Auth({ config, isMaster: false }); +} + +// Returns a promise that resolves to an Auth object +var getAuthForSessionToken = function ({ config, sessionToken, installationId } = {}) { + return config.cacheController.user.get(sessionToken).then(userJSON => { + if (userJSON) { + const cachedUser = Parse.Object.fromJSON(userJSON); + return Promise.resolve(new Auth({ config, isMaster: false, installationId, user: cachedUser })); + } + + var restOptions = { + limit: 1, + include: 'user' + }; + + 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']) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + } + + var now = new Date(), + expiresAt = results[0].expiresAt ? new Date(results[0].expiresAt.iso) : undefined; + if (expiresAt < now) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token is expired.'); + } + var obj = results[0]['user']; + delete obj.password; + obj['className'] = '_User'; + obj['sessionToken'] = sessionToken; + config.cacheController.user.put(sessionToken, obj); + const userObject = Parse.Object.fromJSON(obj); + return new Auth({ config, isMaster: false, installationId, user: userObject }); + }); + }); +}; + +var getAuthForLegacySessionToken = function ({ config, sessionToken, installationId } = {}) { + var restOptions = { + limit: 1 + }; + var query = new RestQuery(config, master(config), '_User', { sessionToken: sessionToken }, restOptions); + return query.execute().then(response => { + var results = response.results; + if (results.length !== 1) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid legacy session token'); + } + const obj = results[0]; + obj.className = '_User'; + const userObject = Parse.Object.fromJSON(obj); + return new Auth({ config, isMaster: false, installationId, user: userObject }); + }); +}; + +// Returns a promise that resolves to an array of role names +Auth.prototype.getUserRoles = function () { + if (this.isMaster || !this.user) { + return Promise.resolve([]); + } + if (this.fetchedRoles) { + return Promise.resolve(this.userRoles); + } + if (this.rolePromise) { + return this.rolePromise; + } + this.rolePromise = this._loadRoles(); + return this.rolePromise; +}; + +// Iterates through the role tree and compiles a users roles +Auth.prototype._loadRoles = function () { + var cacheAdapter = this.config.cacheController; + return cacheAdapter.role.get(this.user.id).then(cachedRoles => { + if (cachedRoles != null) { + this.fetchedRoles = true; + this.userRoles = cachedRoles; + return Promise.resolve(cachedRoles); + } + + var restWhere = { + 'users': { + __type: 'Pointer', + className: '_User', + objectId: this.user.id + } + }; + // First get the role ids this user is directly a member of + var query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {}); + return query.execute().then(response => { + var results = response.results; + if (!results.length) { + this.userRoles = []; + this.fetchedRoles = true; + this.rolePromise = null; + + cacheAdapter.role.put(this.user.id, Array(...this.userRoles)); + return Promise.resolve(this.userRoles); + } + var rolesMap = results.reduce((m, r) => { + m.names.push(r.name); + m.ids.push(r.objectId); + return m; + }, { ids: [], names: [] }); + + // run the recursive finding + return this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names).then(roleNames => { + this.userRoles = roleNames.map(r => { + return 'role:' + r; + }); + this.fetchedRoles = true; + this.rolePromise = null; + cacheAdapter.role.put(this.user.id, Array(...this.userRoles)); + return Promise.resolve(this.userRoles); + }); + }); + }); +}; + +// Given a list of roleIds, find all the parent roles, returns a promise with all names +Auth.prototype._getAllRolesNamesForRoleIds = function (roleIDs, names = [], queriedRoles = {}) { + const ins = roleIDs.filter(roleID => { + return queriedRoles[roleID] !== true; + }).map(roleID => { + // mark as queried + queriedRoles[roleID] = true; + return { + __type: 'Pointer', + className: '_Role', + objectId: roleID + }; + }); + + // all roles are accounted for, return the names + if (ins.length == 0) { + return Promise.resolve([...new Set(names)]); + } + // Build an OR query across all parentRoles + let restWhere; + if (ins.length == 1) { + restWhere = { 'roles': ins[0] }; + } else { + restWhere = { 'roles': { '$in': ins } }; + } + const query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {}); + return query.execute().then(response => { + var results = response.results; + // Nothing found + if (!results.length) { + return Promise.resolve(names); + } + // Map the results with all Ids and names + const resultMap = results.reduce((memo, role) => { + memo.names.push(role.name); + memo.ids.push(role.objectId); + return memo; + }, { ids: [], names: [] }); + // store the new found names + names = names.concat(resultMap.names); + // find the next ones, circular roles will be cut + return this._getAllRolesNamesForRoleIds(resultMap.ids, names, queriedRoles); + }).then(names => { + return Promise.resolve([...new Set(names)]); + }); +}; + +module.exports = { + Auth, + master, + nobody, + readOnly, + getAuthForSessionToken, + getAuthForLegacySessionToken +}; \ No newline at end of file diff --git a/lib/ClientSDK.js b/lib/ClientSDK.js new file mode 100644 index 0000000000..6e029ceb07 --- /dev/null +++ b/lib/ClientSDK.js @@ -0,0 +1,42 @@ +'use strict'; + +var semver = require('semver'); + +function compatible(compatibleSDK) { + return function (clientSDK) { + if (typeof clientSDK === 'string') { + clientSDK = fromString(clientSDK); + } + // REST API, or custom SDK + if (!clientSDK) { + return true; + } + const clientVersion = clientSDK.version; + const compatiblityVersion = compatibleSDK[clientSDK.sdk]; + return semver.satisfies(clientVersion, compatiblityVersion); + }; +} + +function supportsForwardDelete(clientSDK) { + return compatible({ + js: '>=1.9.0' + })(clientSDK); +} + +function fromString(version) { + const versionRE = /([-a-zA-Z]+)([0-9\.]+)/; + const match = version.toLowerCase().match(versionRE); + if (match && match.length === 3) { + return { + sdk: match[1], + version: match[2] + }; + } + return undefined; +} + +module.exports = { + compatible, + supportsForwardDelete, + fromString +}; \ No newline at end of file diff --git a/lib/Config.js b/lib/Config.js new file mode 100644 index 0000000000..71c74906e1 --- /dev/null +++ b/lib/Config.js @@ -0,0 +1,292 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Config = undefined; + +var _cache = require('./cache'); + +var _cache2 = _interopRequireDefault(_cache); + +var _SchemaCache = require('./Controllers/SchemaCache'); + +var _SchemaCache2 = _interopRequireDefault(_SchemaCache); + +var _DatabaseController = require('./Controllers/DatabaseController'); + +var _DatabaseController2 = _interopRequireDefault(_DatabaseController); + +var _net = require('net'); + +var _net2 = _interopRequireDefault(_net); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// A Config object provides information about how a specific app is +// configured. +// mount is the URL for the root of the API; includes http, domain, etc. + +function removeTrailingSlash(str) { + if (!str) { + return str; + } + if (str.endsWith("/")) { + str = str.substr(0, str.length - 1); + } + return str; +} + +class Config { + static get(applicationId, mount) { + const cacheInfo = _cache2.default.get(applicationId); + if (!cacheInfo) { + return; + } + const config = new Config(); + config.applicationId = applicationId; + Object.keys(cacheInfo).forEach(key => { + if (key == 'databaseController') { + const schemaCache = new _SchemaCache2.default(cacheInfo.cacheController, cacheInfo.schemaCacheTTL, cacheInfo.enableSingleSchemaCache); + config.database = new _DatabaseController2.default(cacheInfo.databaseController.adapter, schemaCache); + } else { + config[key] = cacheInfo[key]; + } + }); + config.mount = removeTrailingSlash(mount); + config.generateSessionExpiresAt = config.generateSessionExpiresAt.bind(config); + config.generateEmailVerifyTokenExpiresAt = config.generateEmailVerifyTokenExpiresAt.bind(config); + return config; + } + + static put(serverConfiguration) { + Config.validate(serverConfiguration); + _cache2.default.put(serverConfiguration.appId, serverConfiguration); + Config.setupPasswordValidator(serverConfiguration.passwordPolicy); + return serverConfiguration; + } + + static validate({ + verifyUserEmails, + userController, + appName, + publicServerURL, + revokeSessionOnPasswordReset, + expireInactiveSessions, + sessionLength, + maxLimit, + emailVerifyTokenValidityDuration, + accountLockout, + passwordPolicy, + masterKeyIps, + masterKey, + readOnlyMasterKey + }) { + + if (masterKey === readOnlyMasterKey) { + throw new Error('masterKey and readOnlyMasterKey should be different'); + } + + const emailAdapter = userController.adapter; + if (verifyUserEmails) { + this.validateEmailConfiguration({ emailAdapter, appName, publicServerURL, emailVerifyTokenValidityDuration }); + } + + this.validateAccountLockoutPolicy(accountLockout); + + this.validatePasswordPolicy(passwordPolicy); + + if (typeof revokeSessionOnPasswordReset !== 'boolean') { + throw 'revokeSessionOnPasswordReset must be a boolean value'; + } + + if (publicServerURL) { + if (!publicServerURL.startsWith("http://") && !publicServerURL.startsWith("https://")) { + throw "publicServerURL should be a valid HTTPS URL starting with https://"; + } + } + + this.validateSessionConfiguration(sessionLength, expireInactiveSessions); + + this.validateMasterKeyIps(masterKeyIps); + + this.validateMaxLimit(maxLimit); + } + + static validateAccountLockoutPolicy(accountLockout) { + if (accountLockout) { + if (typeof accountLockout.duration !== 'number' || accountLockout.duration <= 0 || accountLockout.duration > 99999) { + throw 'Account lockout duration should be greater than 0 and less than 100000'; + } + + if (!Number.isInteger(accountLockout.threshold) || accountLockout.threshold < 1 || accountLockout.threshold > 999) { + throw 'Account lockout threshold should be an integer greater than 0 and less than 1000'; + } + } + } + + static validatePasswordPolicy(passwordPolicy) { + if (passwordPolicy) { + if (passwordPolicy.maxPasswordAge !== undefined && (typeof passwordPolicy.maxPasswordAge !== 'number' || passwordPolicy.maxPasswordAge < 0)) { + throw 'passwordPolicy.maxPasswordAge must be a positive number'; + } + + if (passwordPolicy.resetTokenValidityDuration !== undefined && (typeof passwordPolicy.resetTokenValidityDuration !== 'number' || passwordPolicy.resetTokenValidityDuration <= 0)) { + throw 'passwordPolicy.resetTokenValidityDuration must be a positive number'; + } + + if (passwordPolicy.validatorPattern) { + if (typeof passwordPolicy.validatorPattern === 'string') { + passwordPolicy.validatorPattern = new RegExp(passwordPolicy.validatorPattern); + } else if (!(passwordPolicy.validatorPattern instanceof RegExp)) { + throw 'passwordPolicy.validatorPattern must be a regex string or RegExp object.'; + } + } + + if (passwordPolicy.validatorCallback && typeof passwordPolicy.validatorCallback !== 'function') { + throw 'passwordPolicy.validatorCallback must be a function.'; + } + + if (passwordPolicy.doNotAllowUsername && typeof passwordPolicy.doNotAllowUsername !== 'boolean') { + throw 'passwordPolicy.doNotAllowUsername must be a boolean value.'; + } + + if (passwordPolicy.maxPasswordHistory && (!Number.isInteger(passwordPolicy.maxPasswordHistory) || passwordPolicy.maxPasswordHistory <= 0 || passwordPolicy.maxPasswordHistory > 20)) { + throw 'passwordPolicy.maxPasswordHistory must be an integer ranging 0 - 20'; + } + } + } + + // if the passwordPolicy.validatorPattern is configured then setup a callback to process the pattern + static setupPasswordValidator(passwordPolicy) { + if (passwordPolicy && passwordPolicy.validatorPattern) { + passwordPolicy.patternValidator = value => { + return passwordPolicy.validatorPattern.test(value); + }; + } + } + + static validateEmailConfiguration({ emailAdapter, appName, publicServerURL, emailVerifyTokenValidityDuration }) { + if (!emailAdapter) { + throw 'An emailAdapter is required for e-mail verification and password resets.'; + } + if (typeof appName !== 'string') { + throw 'An app name is required for e-mail verification and password resets.'; + } + if (typeof publicServerURL !== 'string') { + throw 'A public server url is required for e-mail verification and password resets.'; + } + if (emailVerifyTokenValidityDuration) { + if (isNaN(emailVerifyTokenValidityDuration)) { + throw 'Email verify token validity duration must be a valid number.'; + } else if (emailVerifyTokenValidityDuration <= 0) { + throw 'Email verify token validity duration must be a value greater than 0.'; + } + } + } + + static validateMasterKeyIps(masterKeyIps) { + for (const ip of masterKeyIps) { + if (!_net2.default.isIP(ip)) { + throw `Invalid ip in masterKeyIps: ${ip}`; + } + } + } + + get mount() { + var mount = this._mount; + if (this.publicServerURL) { + mount = this.publicServerURL; + } + return mount; + } + + set mount(newValue) { + this._mount = newValue; + } + + static validateSessionConfiguration(sessionLength, expireInactiveSessions) { + if (expireInactiveSessions) { + if (isNaN(sessionLength)) { + throw 'Session length must be a valid number.'; + } else if (sessionLength <= 0) { + throw 'Session length must be a value greater than 0.'; + } + } + } + + static validateMaxLimit(maxLimit) { + if (maxLimit <= 0) { + throw 'Max limit must be a value greater than 0.'; + } + } + + generateEmailVerifyTokenExpiresAt() { + if (!this.verifyUserEmails || !this.emailVerifyTokenValidityDuration) { + return undefined; + } + var now = new Date(); + return new Date(now.getTime() + this.emailVerifyTokenValidityDuration * 1000); + } + + generatePasswordResetTokenExpiresAt() { + if (!this.passwordPolicy || !this.passwordPolicy.resetTokenValidityDuration) { + return undefined; + } + const now = new Date(); + return new Date(now.getTime() + this.passwordPolicy.resetTokenValidityDuration * 1000); + } + + generateSessionExpiresAt() { + if (!this.expireInactiveSessions) { + return undefined; + } + var now = new Date(); + return new Date(now.getTime() + this.sessionLength * 1000); + } + + get invalidLinkURL() { + return this.customPages.invalidLink || `${this.publicServerURL}/apps/invalid_link.html`; + } + + get invalidVerificationLinkURL() { + return this.customPages.invalidVerificationLink || `${this.publicServerURL}/apps/invalid_verification_link.html`; + } + + get linkSendSuccessURL() { + return this.customPages.linkSendSuccess || `${this.publicServerURL}/apps/link_send_success.html`; + } + + get linkSendFailURL() { + return this.customPages.linkSendFail || `${this.publicServerURL}/apps/link_send_fail.html`; + } + + get verifyEmailSuccessURL() { + return this.customPages.verifyEmailSuccess || `${this.publicServerURL}/apps/verify_email_success.html`; + } + + get choosePasswordURL() { + return this.customPages.choosePassword || `${this.publicServerURL}/apps/choose_password`; + } + + get requestResetPasswordURL() { + return `${this.publicServerURL}/apps/${this.applicationId}/request_password_reset`; + } + + get passwordResetSuccessURL() { + return this.customPages.passwordResetSuccess || `${this.publicServerURL}/apps/password_reset_success.html`; + } + + get parseFrameURL() { + return this.customPages.parseFrameURL; + } + + get verifyEmailURL() { + return `${this.publicServerURL}/apps/${this.applicationId}/verify_email`; + } +} + +exports.Config = Config; +exports.default = Config; + +module.exports = Config; \ No newline at end of file diff --git a/lib/Controllers/AdaptableController.js b/lib/Controllers/AdaptableController.js new file mode 100644 index 0000000000..c782269d77 --- /dev/null +++ b/lib/Controllers/AdaptableController.js @@ -0,0 +1,86 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AdaptableController = undefined; + +var _Config = require("../Config"); + +var _Config2 = _interopRequireDefault(_Config); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/* +AdaptableController.js + +AdaptableController is the base class for all controllers +that support adapter, +The super class takes care of creating the right instance for the adapter +based on the parameters passed + + */ + +// _adapter is private, use Symbol +var _adapter = Symbol(); +class AdaptableController { + + constructor(adapter, appId, options) { + this.options = options; + this.appId = appId; + this.adapter = adapter; + } + + set adapter(adapter) { + this.validateAdapter(adapter); + this[_adapter] = adapter; + } + + get adapter() { + return this[_adapter]; + } + + get config() { + return _Config2.default.get(this.appId); + } + + expectedAdapterType() { + throw new Error("Subclasses should implement expectedAdapterType()"); + } + + validateAdapter(adapter) { + AdaptableController.validateAdapter(adapter, this); + } + + static validateAdapter(adapter, self, ExpectedType) { + if (!adapter) { + throw new Error(this.constructor.name + " requires an adapter"); + } + + const Type = ExpectedType || self.expectedAdapterType(); + // Allow skipping for testing + if (!Type) { + return; + } + + // Makes sure the prototype matches + const 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; + }, {}); + + if (Object.keys(mismatches).length > 0) { + throw new Error("Adapter prototype don't match expected prototype", adapter, mismatches); + } + } +} + +exports.AdaptableController = AdaptableController; +exports.default = AdaptableController; \ No newline at end of file diff --git a/lib/Controllers/AnalyticsController.js b/lib/Controllers/AnalyticsController.js new file mode 100644 index 0000000000..a54cf91666 --- /dev/null +++ b/lib/Controllers/AnalyticsController.js @@ -0,0 +1,43 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AnalyticsController = undefined; + +var _AdaptableController = require('./AdaptableController'); + +var _AdaptableController2 = _interopRequireDefault(_AdaptableController); + +var _AnalyticsAdapter = require('../Adapters/Analytics/AnalyticsAdapter'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class AnalyticsController extends _AdaptableController2.default { + appOpened(req) { + return Promise.resolve().then(() => { + return this.adapter.appOpened(req.body, req); + }).then(response => { + return { response: response || {} }; + }).catch(() => { + return { response: {} }; + }); + } + + trackEvent(req) { + return Promise.resolve().then(() => { + return this.adapter.trackEvent(req.params.eventName, req.body, req); + }).then(response => { + return { response: response || {} }; + }).catch(() => { + return { response: {} }; + }); + } + + expectedAdapterType() { + return _AnalyticsAdapter.AnalyticsAdapter; + } +} + +exports.AnalyticsController = AnalyticsController; +exports.default = AnalyticsController; \ No newline at end of file diff --git a/lib/Controllers/CacheController.js b/lib/Controllers/CacheController.js new file mode 100644 index 0000000000..5b0466cbb0 --- /dev/null +++ b/lib/Controllers/CacheController.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.CacheController = exports.SubCache = undefined; + +var _AdaptableController = require('./AdaptableController'); + +var _AdaptableController2 = _interopRequireDefault(_AdaptableController); + +var _CacheAdapter = require('../Adapters/Cache/CacheAdapter'); + +var _CacheAdapter2 = _interopRequireDefault(_CacheAdapter); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const KEY_SEPARATOR_CHAR = ':'; + +function joinKeys(...keys) { + return keys.join(KEY_SEPARATOR_CHAR); +} + +/** + * Prefix all calls to the cache via a prefix string, useful when grouping Cache by object type. + * + * eg "Role" or "Session" + */ +class SubCache { + constructor(prefix, cacheController, ttl) { + this.prefix = prefix; + this.cache = cacheController; + this.ttl = ttl; + } + + get(key) { + const cacheKey = joinKeys(this.prefix, key); + return this.cache.get(cacheKey); + } + + put(key, value, ttl) { + const cacheKey = joinKeys(this.prefix, key); + return this.cache.put(cacheKey, value, ttl); + } + + del(key) { + const cacheKey = joinKeys(this.prefix, key); + return this.cache.del(cacheKey); + } + + clear() { + return this.cache.clear(); + } +} + +exports.SubCache = SubCache; +class CacheController extends _AdaptableController2.default { + + constructor(adapter, appId, options = {}) { + super(adapter, appId, options); + + this.role = new SubCache('role', this); + this.user = new SubCache('user', this); + } + + get(key) { + const cacheKey = joinKeys(this.appId, key); + return this.adapter.get(cacheKey).then(null, () => Promise.resolve(null)); + } + + put(key, value, ttl) { + const cacheKey = joinKeys(this.appId, key); + return this.adapter.put(cacheKey, value, ttl); + } + + del(key) { + const cacheKey = joinKeys(this.appId, key); + return this.adapter.del(cacheKey); + } + + clear() { + return this.adapter.clear(); + } + + expectedAdapterType() { + return _CacheAdapter2.default; + } +} + +exports.CacheController = CacheController; +exports.default = CacheController; \ No newline at end of file diff --git a/lib/Controllers/DatabaseController.js b/lib/Controllers/DatabaseController.js new file mode 100644 index 0000000000..30c9d24fde --- /dev/null +++ b/lib/Controllers/DatabaseController.js @@ -0,0 +1,1016 @@ +'use strict'; + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +var _node = require('parse/node'); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _intersect = require('intersect'); + +var _intersect2 = _interopRequireDefault(_intersect); + +var _deepcopy = require('deepcopy'); + +var _deepcopy2 = _interopRequireDefault(_deepcopy); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +var _SchemaController = require('./SchemaController'); + +var SchemaController = _interopRequireWildcard(_SchemaController); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } // A database adapter that works with data exported from the hosted +// Parse database. + +function addWriteACL(query, acl) { + const newQuery = _lodash2.default.cloneDeep(query); + //Can't be any existing '_wperm' query, we don't allow client queries on that, no need to $and + newQuery._wperm = { "$in": [null, ...acl] }; + return newQuery; +} + +function addReadACL(query, acl) { + const newQuery = _lodash2.default.cloneDeep(query); + //Can't be any existing '_rperm' query, we don't allow client queries on that, no need to $and + newQuery._rperm = { "$in": [null, "*", ...acl] }; + return newQuery; +} + +// Transforms a REST API formatted ACL object to our two-field mongo format. +const transformObjectACL = (_ref) => { + let { ACL } = _ref, + result = _objectWithoutProperties(_ref, ['ACL']); + + if (!ACL) { + return result; + } + + result._wperm = []; + result._rperm = []; + + for (const entry in ACL) { + if (ACL[entry].read) { + result._rperm.push(entry); + } + if (ACL[entry].write) { + result._wperm.push(entry); + } + } + return 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 _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Cannot query on ACL.'); + } + + if (query.$or) { + if (query.$or instanceof Array) { + query.$or.forEach(validateQuery); + + /* In MongoDB, $or queries which are not alone at the top level of the + * query can not make efficient use of indexes due to a long standing + * bug known as SERVER-13732. + * + * This block restructures queries in which $or is not the sole top + * level element by moving all other top-level predicates inside every + * subdocument of the $or predicate, allowing MongoDB's query planner + * to make full use of the most relevant indexes. + * + * EG: {$or: [{a: 1}, {a: 2}], b: 2} + * Becomes: {$or: [{a: 1, b: 2}, {a: 2, b: 2}]} + * + * The only exceptions are $near and $nearSphere operators, which are + * constrained to only 1 operator per query. As a result, these ops + * remain at the top level + * + * https://jira.mongodb.org/browse/SERVER-13732 + * https://github.com/parse-community/parse-server/issues/3767 + */ + Object.keys(query).forEach(key => { + const noCollisions = !query.$or.some(subq => subq.hasOwnProperty(key)); + let hasNears = false; + if (query[key] != null && typeof query[key] == 'object') { + hasNears = '$near' in query[key] || '$nearSphere' in query[key]; + } + if (key != '$or' && noCollisions && !hasNears) { + query.$or.forEach(subquery => { + subquery[key] = query[key]; + }); + delete query[key]; + } + }); + query.$or.forEach(validateQuery); + } else { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Bad $or format - use an array value.'); + } + } + + if (query.$and) { + if (query.$and instanceof Array) { + query.$and.forEach(validateQuery); + } else { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Bad $and format - use an array value.'); + } + } + + Object.keys(query).forEach(key => { + if (query && query[key] && query[key].$regex) { + if (typeof query[key].$options === 'string') { + if (!query[key].$options.match(/^[imxs]+$/)) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, `Bad $options value for query: ${query[key].$options}`); + } + } + } + if (!isSpecialQueryKey(key) && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid key name: ${key}`); + } + }); +}; + +function DatabaseController(adapter, schemaCache) { + this.adapter = adapter; + this.schemaCache = schemaCache; + // We don't want a mutable this.schema, because then you could have + // one request that uses different schemas for different parts of + // it. Instead, use loadSchema to get a schema. + this.schemaPromise = null; +} + +DatabaseController.prototype.collectionExists = function (className) { + return this.adapter.classExists(className); +}; + +DatabaseController.prototype.purgeCollection = function (className) { + return this.loadSchema().then(schemaController => schemaController.getOneSchema(className)).then(schema => this.adapter.deleteObjectsByQuery(className, schema, {})); +}; + +DatabaseController.prototype.validateClassName = function (className) { + if (!SchemaController.classNameIsValid(className)) { + return Promise.reject(new _node.Parse.Error(_node.Parse.Error.INVALID_CLASS_NAME, 'invalid className: ' + className)); + } + return Promise.resolve(); +}; + +// Returns a promise for a schemaController. +DatabaseController.prototype.loadSchema = function (options = { clearCache: false }) { + if (!this.schemaPromise) { + this.schemaPromise = SchemaController.load(this.adapter, this.schemaCache, options); + this.schemaPromise.then(() => delete this.schemaPromise, () => delete this.schemaPromise); + } + return this.schemaPromise; +}; + +// Returns a promise for the classname that is related to the given +// classname through the key. +// TODO: make this not in the DatabaseController interface +DatabaseController.prototype.redirectClassNameForKey = function (className, key) { + return this.loadSchema().then(schema => { + var t = schema.getExpectedType(className, key); + if (t && t.type == 'Relation') { + return t.targetClass; + } else { + return className; + } + }); +}; + +// Uses the schema to validate the object (REST API format). +// Returns a promise that resolves to the new schema. +// This does not update this.schema, because in a situation like a +// batch request, that could confuse other users of the schema. +DatabaseController.prototype.validateObject = function (className, object, query, { acl }) { + let schema; + const isMaster = acl === undefined; + var aclGroup = acl || []; + return this.loadSchema().then(s => { + schema = s; + if (isMaster) { + return Promise.resolve(); + } + return this.canAddField(schema, className, object, aclGroup); + }).then(() => { + return schema.validateObject(className, object, query); + }); +}; + +// Filters out any data that shouldn't be on this REST-formatted object. +const filterSensitiveData = (isMaster, aclGroup, className, object) => { + if (className !== '_User') { + return object; + } + + object.password = object._hashed_password; + delete object._hashed_password; + + delete object.sessionToken; + + if (isMaster) { + return object; + } + delete object._email_verify_token; + delete object._perishable_token; + delete object._perishable_token_expires_at; + delete object._tombstone; + delete object._email_verify_token_expires_at; + delete object._failed_login_count; + delete object._account_lockout_expires_at; + delete object._password_changed_at; + + if (aclGroup.indexOf(object.objectId) > -1) { + return object; + } + delete object.authData; + return object; +}; + +// Runs an update on the database. +// Returns a promise for an object with the new values for field +// modifications that don't know their results ahead of time, like +// 'increment'. +// Options: +// acl: a list of strings. If the object to be updated has an ACL, +// 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', '_perishable_token_expires_at', '_password_changed_at', '_password_history']; + +const isSpecialUpdateKey = key => { + return specialKeysForUpdate.indexOf(key) >= 0; +}; + +DatabaseController.prototype.update = function (className, query, update, { + acl, + many, + upsert +} = {}, skipSanitization = false) { + const originalQuery = query; + const originalUpdate = update; + // Make a copy of the object, so we don't mutate the incoming data. + update = (0, _deepcopy2.default)(update); + var relationUpdates = []; + var isMaster = acl === undefined; + var aclGroup = acl || []; + return this.loadSchema().then(schemaController => { + return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'update')).then(() => { + relationUpdates = this.collectRelationUpdates(className, originalQuery.objectId, update); + if (!isMaster) { + query = this.addPointerPermissions(schemaController, className, 'update', query, aclGroup); + } + if (!query) { + return Promise.resolve(); + } + if (acl) { + query = addWriteACL(query, acl); + } + validateQuery(query); + return schemaController.getOneSchema(className, true).catch(error => { + // If the schema doesn't exist, pretend it exists with no fields. This behavior + // will likely need revisiting. + if (error === undefined) { + return { fields: {} }; + } + throw error; + }).then(schema => { + Object.keys(update).forEach(fieldName => { + if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`); + } + fieldName = fieldName.split('.')[0]; + if (!SchemaController.fieldNameIsValid(fieldName) && !isSpecialUpdateKey(fieldName)) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`); + } + }); + for (const updateOperation in update) { + if (Object.keys(updateOperation).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters"); + } + } + update = transformObjectACL(update); + transformAuthData(className, update, schema); + if (many) { + return this.adapter.updateObjectsByQuery(className, schema, query, update); + } else if (upsert) { + return this.adapter.upsertOneObject(className, schema, query, update); + } else { + return this.adapter.findOneAndUpdate(className, schema, query, update); + } + }); + }).then(result => { + if (!result) { + return Promise.reject(new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.')); + } + return this.handleRelationUpdates(className, originalQuery.objectId, update, relationUpdates).then(() => { + return result; + }); + }).then(result => { + if (skipSanitization) { + return Promise.resolve(result); + } + return sanitizeDatabaseResult(originalUpdate, result); + }); + }); +}; + +function expandResultOnKeyPath(object, key, value) { + if (key.indexOf('.') < 0) { + object[key] = value[key]; + return object; + } + const path = key.split('.'); + const firstKey = path[0]; + const nextPath = path.slice(1).join('.'); + object[firstKey] = expandResultOnKeyPath(object[firstKey] || {}, nextPath, value[firstKey]); + delete object[key]; + return object; +} + +function sanitizeDatabaseResult(originalObject, result) { + const response = {}; + if (!result) { + return Promise.resolve(response); + } + Object.keys(originalObject).forEach(key => { + const keyUpdate = originalObject[key]; + // determine if that was an op + if (keyUpdate && typeof keyUpdate === 'object' && keyUpdate.__op && ['Add', 'AddUnique', 'Remove', 'Increment'].indexOf(keyUpdate.__op) > -1) { + // only valid ops that produce an actionable result + // the op may have happend on a keypath + expandResultOnKeyPath(response, key, result); + } + }); + return Promise.resolve(response); +} + +// Collect all relation-updating operations from a REST-format update. +// Returns a list of all relation updates to perform +// This mutates update. +DatabaseController.prototype.collectRelationUpdates = function (className, objectId, update) { + var ops = []; + var deleteMe = []; + objectId = update.objectId || objectId; + + var process = (op, key) => { + if (!op) { + return; + } + if (op.__op == 'AddRelation') { + ops.push({ key, op }); + deleteMe.push(key); + } + + if (op.__op == 'RemoveRelation') { + ops.push({ key, op }); + deleteMe.push(key); + } + + if (op.__op == 'Batch') { + for (var x of op.ops) { + process(x, key); + } + } + }; + + for (const key in update) { + process(update[key], key); + } + for (const key of deleteMe) { + delete update[key]; + } + return ops; +}; + +// Processes relation-updating operations from a REST-format update. +// Returns a promise that resolves when all updates have been performed +DatabaseController.prototype.handleRelationUpdates = function (className, objectId, update, ops) { + var pending = []; + objectId = update.objectId || objectId; + ops.forEach(({ key, op }) => { + if (!op) { + return; + } + if (op.__op == 'AddRelation') { + for (const object of op.objects) { + pending.push(this.addRelation(key, className, objectId, object.objectId)); + } + } + + if (op.__op == 'RemoveRelation') { + for (const object of op.objects) { + pending.push(this.removeRelation(key, className, objectId, object.objectId)); + } + } + }); + + return Promise.all(pending); +}; + +// Adds a relation. +// Returns a promise that resolves successfully iff the add was successful. +const relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } }; +DatabaseController.prototype.addRelation = function (key, fromClassName, fromId, toId) { + const doc = { + relatedId: toId, + owningId: fromId + }; + return this.adapter.upsertOneObject(`_Join:${key}:${fromClassName}`, relationSchema, doc, doc); +}; + +// Removes a relation. +// Returns a promise that resolves successfully iff the remove was +// successful. +DatabaseController.prototype.removeRelation = function (key, fromClassName, fromId, toId) { + var doc = { + relatedId: toId, + owningId: fromId + }; + return this.adapter.deleteObjectsByQuery(`_Join:${key}:${fromClassName}`, relationSchema, doc).catch(error => { + // We don't care if they try to delete a non-existent relation. + if (error.code == _node.Parse.Error.OBJECT_NOT_FOUND) { + return; + } + throw error; + }); +}; + +// Removes objects matches this query from the database. +// Returns a promise that resolves successfully iff the object was +// deleted. +// Options: +// acl: a list of strings. If the object to be updated has an ACL, +// one of the provided strings must provide the caller with +// write permissions. +DatabaseController.prototype.destroy = function (className, query, { acl } = {}) { + const isMaster = acl === undefined; + const aclGroup = acl || []; + + return this.loadSchema().then(schemaController => { + return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'delete')).then(() => { + if (!isMaster) { + query = this.addPointerPermissions(schemaController, className, 'delete', query, aclGroup); + if (!query) { + throw new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.'); + } + } + // delete by query + if (acl) { + query = addWriteACL(query, acl); + } + validateQuery(query); + return schemaController.getOneSchema(className).catch(error => { + // If the schema doesn't exist, pretend it exists with no fields. This behavior + // will likely need revisiting. + if (error === undefined) { + return { fields: {} }; + } + throw error; + }).then(parseFormatSchema => this.adapter.deleteObjectsByQuery(className, parseFormatSchema, query)).catch(error => { + // When deleting sessions while changing passwords, don't throw an error if they don't have any sessions. + if (className === "_Session" && error.code === _node.Parse.Error.OBJECT_NOT_FOUND) { + return Promise.resolve({}); + } + throw error; + }); + }); + }); +}; + +const flattenUpdateOperatorsForCreate = object => { + for (const key in object) { + if (object[key] && object[key].__op) { + switch (object[key].__op) { + case 'Increment': + if (typeof object[key].amount !== 'number') { + throw new _node.Parse.Error(_node.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 _node.Parse.Error(_node.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 _node.Parse.Error(_node.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 _node.Parse.Error(_node.Parse.Error.INVALID_JSON, 'objects to add must be an array'); + } + object[key] = []; + break; + case 'Delete': + delete object[key]; + break; + default: + throw new _node.Parse.Error(_node.Parse.Error.COMMAND_UNAVAILABLE, `The ${object[key].__op} operator is not supported yet.`); + } + } + } +}; + +const transformAuthData = (className, object, schema) => { + if (object.authData && className === '_User') { + Object.keys(object.authData).forEach(provider => { + const providerData = object.authData[provider]; + const fieldName = `_auth_data_${provider}`; + if (providerData == null) { + object[fieldName] = { + __op: 'Delete' + }; + } else { + object[fieldName] = providerData; + schema.fields[fieldName] = { type: 'Object' }; + } + }); + delete object.authData; + } +}; + +// Inserts an object into the database. +// Returns a promise that resolves successfully iff the object saved. +DatabaseController.prototype.create = function (className, object, { acl } = {}) { + // Make a copy of the object, so we don't mutate the incoming data. + const originalObject = object; + object = transformObjectACL(object); + + object.createdAt = { iso: object.createdAt, __type: 'Date' }; + object.updatedAt = { iso: object.updatedAt, __type: 'Date' }; + + var isMaster = acl === undefined; + var aclGroup = acl || []; + const relationUpdates = this.collectRelationUpdates(className, null, object); + return this.validateClassName(className).then(() => this.loadSchema()).then(schemaController => { + return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'create')).then(() => schemaController.enforceClassExists(className)).then(() => schemaController.reloadData()).then(() => schemaController.getOneSchema(className, true)).then(schema => { + transformAuthData(className, object, schema); + flattenUpdateOperatorsForCreate(object); + return this.adapter.createObject(className, SchemaController.convertSchemaToAdapterSchema(schema), object); + }).then(result => { + return this.handleRelationUpdates(className, null, object, relationUpdates).then(() => { + return sanitizeDatabaseResult(originalObject, result.ops[0]); + }); + }); + }); +}; + +DatabaseController.prototype.canAddField = function (schema, className, object, aclGroup) { + const classSchema = schema.data[className]; + if (!classSchema) { + return Promise.resolve(); + } + const fields = Object.keys(object); + const schemaFields = Object.keys(classSchema); + const newKeys = fields.filter(field => { + return schemaFields.indexOf(field) < 0; + }); + if (newKeys.length > 0) { + return schema.validatePermission(className, aclGroup, 'addField'); + } + return Promise.resolve(); +}; + +// Won't delete collections in the system namespace +// Returns a promise. +DatabaseController.prototype.deleteEverything = function () { + this.schemaPromise = null; + return Promise.all([this.adapter.deleteAllClasses(), this.schemaCache.clear()]); +}; + +// 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, queryOptions) { + const { skip, limit, sort } = queryOptions; + const findOptions = {}; + if (sort && sort.createdAt && this.adapter.canSortOnJoinTables) { + findOptions.sort = { '_id': sort.createdAt }; + findOptions.limit = limit; + findOptions.skip = skip; + queryOptions.skip = 0; + } + return this.adapter.find(joinTableName(className, key), relationSchema, { owningId }, findOptions).then(results => results.map(result => result.relatedId)); +}; + +// Returns a promise for a list of owning ids given some related ids. +// className here is the owning className. +DatabaseController.prototype.owningIds = function (className, key, relatedIds) { + return this.adapter.find(joinTableName(className, key), relationSchema, { relatedId: { '$in': relatedIds } }, {}).then(results => results.map(result => result.owningId)); +}; + +// Modifies query so that it no longer has $in on relation fields, or +// equal-to-pointer constraints on relation fields. +// Returns a promise that resolves when query is mutated +DatabaseController.prototype.reduceInRelation = function (className, query, schema) { + + // Search for an in-relation or equal-to-relation + // Make it sequential for now, not sure of paralleization side effects + if (query['$or']) { + const ors = query['$or']; + return Promise.all(ors.map((aQuery, index) => { + return this.reduceInRelation(className, aQuery, schema).then(aQuery => { + query['$or'][index] = aQuery; + }); + })).then(() => { + return Promise.resolve(query); + }); + } + + const promises = Object.keys(query).map(key => { + const t = schema.getExpectedType(className, key); + if (!t || t.type !== 'Relation') { + return Promise.resolve(query); + } + let queries = null; + if (query[key] && (query[key]['$in'] || query[key]['$ne'] || query[key]['$nin'] || query[key].__type == 'Pointer')) { + // Build the list of queries + queries = Object.keys(query[key]).map(constraintKey => { + let relatedIds; + let isNegation = false; + if (constraintKey === 'objectId') { + relatedIds = [query[key].objectId]; + } else if (constraintKey == '$in') { + relatedIds = query[key]['$in'].map(r => r.objectId); + } else if (constraintKey == '$nin') { + isNegation = true; + relatedIds = query[key]['$nin'].map(r => r.objectId); + } else if (constraintKey == '$ne') { + isNegation = true; + relatedIds = [query[key]['$ne'].objectId]; + } else { + return; + } + return { + isNegation, + relatedIds + }; + }); + } else { + queries = [{ isNegation: false, relatedIds: [] }]; + } + + // remove the current queryKey as we don,t need it anymore + delete query[key]; + // execute each query independently to build the list of + // $in / $nin + const promises = queries.map(q => { + if (!q) { + return Promise.resolve(); + } + return this.owningIds(className, key, q.relatedIds).then(ids => { + if (q.isNegation) { + this.addNotInObjectIdsIds(ids, query); + } else { + this.addInObjectIdsIds(ids, query); + } + return Promise.resolve(); + }); + }); + + return Promise.all(promises).then(() => { + return Promise.resolve(); + }); + }); + + return Promise.all(promises).then(() => { + return Promise.resolve(query); + }); +}; + +// Modifies query so that it no longer has $relatedTo +// Returns a promise that resolves when query is mutated +DatabaseController.prototype.reduceRelationKeys = function (className, query, queryOptions) { + + if (query['$or']) { + return Promise.all(query['$or'].map(aQuery => { + return this.reduceRelationKeys(className, aQuery, queryOptions); + })); + } + + var relatedTo = query['$relatedTo']; + if (relatedTo) { + return this.relatedIds(relatedTo.object.className, relatedTo.key, relatedTo.object.objectId, queryOptions).then(ids => { + delete query['$relatedTo']; + this.addInObjectIdsIds(ids, query); + return this.reduceRelationKeys(className, query, queryOptions); + }); + } +}; + +DatabaseController.prototype.addInObjectIdsIds = function (ids = null, query) { + const idsFromString = typeof query.objectId === 'string' ? [query.objectId] : null; + const idsFromEq = query.objectId && query.objectId['$eq'] ? [query.objectId['$eq']] : null; + const idsFromIn = query.objectId && query.objectId['$in'] ? query.objectId['$in'] : null; + + const allIds = [idsFromString, idsFromEq, idsFromIn, ids].filter(list => list !== null); + const totalLength = allIds.reduce((memo, list) => memo + list.length, 0); + + let idsIntersection = []; + if (totalLength > 125) { + idsIntersection = _intersect2.default.big(allIds); + } else { + idsIntersection = (0, _intersect2.default)(allIds); + } + + // Need to make sure we don't clobber existing shorthand $eq constraints on objectId. + if (!('objectId' in query)) { + query.objectId = {}; + } else if (typeof query.objectId === 'string') { + query.objectId = { + $eq: query.objectId + }; + } + query.objectId['$in'] = idsIntersection; + + return query; +}; + +DatabaseController.prototype.addNotInObjectIdsIds = function (ids = [], query) { + const idsFromNin = query.objectId && query.objectId['$nin'] ? query.objectId['$nin'] : []; + let allIds = [...idsFromNin, ...ids].filter(list => list !== null); + + // make a set and spread to remove duplicates + allIds = [...new Set(allIds)]; + + // Need to make sure we don't clobber existing shorthand $eq constraints on objectId. + if (!('objectId' in query)) { + query.objectId = {}; + } else if (typeof query.objectId === 'string') { + query.objectId = { + $eq: query.objectId + }; + } + + query.objectId['$nin'] = allIds; + return query; +}; + +// Runs a query on the database. +// Returns a promise that resolves to a list of items. +// Options: +// skip number of results to skip. +// limit limit to this number of results. +// sort an object where keys are the fields to sort by. +// the value is +1 for ascending, -1 for descending. +// count run a count instead of returning results. +// acl restrict this operation with an ACL for the provided array +// of user objectIds and roles. acl: null means no user. +// when this field is not present, don't do anything regarding ACLs. +// TODO: make userIds not needed here. The db adapter shouldn't know +// anything about users, ideally. Then, improve the format of the ACL +// arg to work like the others. +DatabaseController.prototype.find = function (className, query, { + skip, + limit, + acl, + sort = {}, + count, + keys, + op, + distinct, + pipeline, + readPreference +} = {}) { + const isMaster = acl === undefined; + const aclGroup = acl || []; + op = op || (typeof query.objectId == 'string' && Object.keys(query).length === 1 ? 'get' : 'find'); + // Count operation if counting + op = count === true ? 'count' : op; + + let classExists = true; + return this.loadSchema().then(schemaController => { + //Allow volatile classes if querying with Master (for _PushStatus) + //TODO: Move volatile classes concept into mongo adapter, postgres adapter shouldn't care + //that api.parse.com breaks when _PushStatus exists in mongo. + return schemaController.getOneSchema(className, isMaster).catch(error => { + // Behavior for non-existent classes is kinda weird on Parse.com. Probably doesn't matter too much. + // For now, pretend the class exists but has no objects, + if (error === undefined) { + classExists = false; + return { fields: {} }; + } + throw error; + }).then(schema => { + // Parse.com treats queries on _created_at and _updated_at as if they were queries on createdAt and updatedAt, + // so duplicate that behavior here. If both are specified, the correct behavior to match Parse.com is to + // use the one that appears first in the sort list. + if (sort._created_at) { + sort.createdAt = sort._created_at; + delete sort._created_at; + } + if (sort._updated_at) { + sort.updatedAt = sort._updated_at; + delete sort._updated_at; + } + Object.keys(sort).forEach(fieldName => { + if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Cannot sort by ${fieldName}`); + } + if (!SchemaController.fieldNameIsValid(fieldName)) { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`); + } + }); + const queryOptions = { skip, limit, sort, keys, readPreference }; + return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, op)).then(() => this.reduceRelationKeys(className, query, queryOptions)).then(() => this.reduceInRelation(className, query, schemaController)).then(() => { + if (!isMaster) { + query = this.addPointerPermissions(schemaController, className, op, query, aclGroup); + } + if (!query) { + if (op == 'get') { + throw new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found.'); + } else { + return []; + } + } + if (!isMaster) { + query = addReadACL(query, aclGroup); + } + validateQuery(query); + if (count) { + if (!classExists) { + return 0; + } else { + return this.adapter.count(className, schema, query, readPreference); + } + } else if (distinct) { + if (!classExists) { + return []; + } else { + return this.adapter.distinct(className, schema, query, distinct); + } + } else if (pipeline) { + if (!classExists) { + return []; + } else { + return this.adapter.aggregate(className, schema, pipeline, readPreference); + } + } else { + if (!classExists) { + return []; + } else { + return this.adapter.find(className, schema, query, queryOptions).then(objects => objects.map(object => { + object = untransformObjectACL(object); + return filterSensitiveData(isMaster, aclGroup, className, object); + })).catch(error => { + throw new _node.Parse.Error(_node.Parse.Error.INTERNAL_SERVER_ERROR, error); + }); + } + } + }); + }); + }); +}; + +// Transforms a Database format ACL to a REST API format ACL +const untransformObjectACL = (_ref2) => { + let { _rperm, _wperm } = _ref2, + output = _objectWithoutProperties(_ref2, ['_rperm', '_wperm']); + + if (_rperm || _wperm) { + output.ACL = {}; + + (_rperm || []).forEach(entry => { + if (!output.ACL[entry]) { + output.ACL[entry] = { read: true }; + } else { + output.ACL[entry]['read'] = true; + } + }); + + (_wperm || []).forEach(entry => { + if (!output.ACL[entry]) { + output.ACL[entry] = { write: true }; + } else { + output.ACL[entry]['write'] = true; + } + }); + } + return output; +}; + +DatabaseController.prototype.deleteSchema = function (className) { + return this.loadSchema(true).then(schemaController => schemaController.getOneSchema(className, true)).catch(error => { + if (error === undefined) { + return { fields: {} }; + } else { + throw error; + } + }).then(schema => { + return this.collectionExists(className).then(() => this.adapter.count(className, { fields: {} })).then(count => { + if (count > 0) { + throw new _node.Parse.Error(255, `Class ${className} is not empty, contains ${count} objects, cannot drop schema.`); + } + return this.adapter.deleteClass(className); + }).then(wasParseCollection => { + if (wasParseCollection) { + const relationFieldNames = Object.keys(schema.fields).filter(fieldName => schema.fields[fieldName].type === 'Relation'); + return Promise.all(relationFieldNames.map(name => this.adapter.deleteClass(joinTableName(className, name)))); + } else { + return Promise.resolve(); + } + }); + }); +}; + +DatabaseController.prototype.addPointerPermissions = function (schema, className, operation, query, aclGroup = []) { + // Check if class has public permission for operation + // If the BaseCLP pass, let go through + if (schema.testBaseCLP(className, aclGroup, operation)) { + return query; + } + const perms = schema.perms[className]; + const field = ['get', 'find'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields'; + const userACL = aclGroup.filter(acl => { + return acl.indexOf('role:') != 0 && acl != '*'; + }); + // the ACL should have exactly 1 user + if (perms && perms[field] && perms[field].length > 0) { + // No user set return undefined + // If the length is > 1, that means we didn't de-dupe users correctly + if (userACL.length != 1) { + return; + } + const userId = userACL[0]; + const userPointer = { + "__type": "Pointer", + "className": "_User", + "objectId": userId + }; + + const permFields = perms[field]; + const ors = permFields.map(key => { + const q = { + [key]: userPointer + }; + // if we already have a constraint on the key, use the $and + if (query.hasOwnProperty(key)) { + return { '$and': [q, query] }; + } + // otherwise just add the constaint + return Object.assign({}, query, { + [`${key}`]: userPointer + }); + }); + if (ors.length > 1) { + return { '$or': ors }; + } + return ors[0]; + } else { + return query; + } +}; + +// TODO: create indexes on first creation of a _User object. Otherwise it's impossible to +// have a Parse app without it having a _User collection. +DatabaseController.prototype.performInitialization = function () { + const requiredUserFields = { fields: _extends({}, SchemaController.defaultColumns._Default, SchemaController.defaultColumns._User) }; + const requiredRoleFields = { fields: _extends({}, SchemaController.defaultColumns._Default, SchemaController.defaultColumns._Role) }; + + const userClassPromise = this.loadSchema().then(schema => schema.enforceClassExists('_User')); + const roleClassPromise = this.loadSchema().then(schema => schema.enforceClassExists('_Role')); + + const usernameUniqueness = userClassPromise.then(() => this.adapter.ensureUniqueness('_User', requiredUserFields, ['username'])).catch(error => { + _logger2.default.warn('Unable to ensure uniqueness for usernames: ', error); + throw error; + }); + + const emailUniqueness = userClassPromise.then(() => this.adapter.ensureUniqueness('_User', requiredUserFields, ['email'])).catch(error => { + _logger2.default.warn('Unable to ensure uniqueness for user email addresses: ', error); + throw error; + }); + + const roleUniqueness = roleClassPromise.then(() => this.adapter.ensureUniqueness('_Role', requiredRoleFields, ['name'])).catch(error => { + _logger2.default.warn('Unable to ensure uniqueness for role name: ', error); + throw error; + }); + + const indexPromise = this.adapter.updateSchemaWithIndexes(); + + // Create tables for volatile classes + const adapterInit = this.adapter.performInitialization({ VolatileClassesSchemas: SchemaController.VolatileClassesSchemas }); + return Promise.all([usernameUniqueness, emailUniqueness, roleUniqueness, adapterInit, indexPromise]); +}; + +function joinTableName(className, key) { + return `_Join:${key}:${className}`; +} + +// Expose validateQuery for tests +DatabaseController._validateQuery = validateQuery; +module.exports = DatabaseController; \ No newline at end of file diff --git a/lib/Controllers/FilesController.js b/lib/Controllers/FilesController.js new file mode 100644 index 0000000000..8cbfc6596f --- /dev/null +++ b/lib/Controllers/FilesController.js @@ -0,0 +1,108 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.FilesController = undefined; + +var _cryptoUtils = require('../cryptoUtils'); + +var _AdaptableController = require('./AdaptableController'); + +var _AdaptableController2 = _interopRequireDefault(_AdaptableController); + +var _FilesAdapter = require('../Adapters/Files/FilesAdapter'); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _mime = require('mime'); + +var _mime2 = _interopRequireDefault(_mime); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const legacyFilesRegex = new RegExp("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}-.*"); // FilesController.js +class FilesController extends _AdaptableController2.default { + + getFileData(config, filename) { + return this.adapter.getFileData(filename); + } + + createFile(config, filename, data, contentType) { + + const extname = _path2.default.extname(filename); + + const hasExtension = extname.length > 0; + + if (!hasExtension && contentType && _mime2.default.getExtension(contentType)) { + filename = filename + '.' + _mime2.default.getExtension(contentType); + } else if (hasExtension && !contentType) { + contentType = _mime2.default.getType(filename); + } + + filename = (0, _cryptoUtils.randomHexString)(32) + '_' + filename; + + var location = this.adapter.getFileLocation(config, filename); + return this.adapter.createFile(filename, data, contentType).then(() => { + return Promise.resolve({ + url: location, + name: filename + }); + }); + } + + deleteFile(config, filename) { + return this.adapter.deleteFile(filename); + } + + /** + * Find file references in REST-format object and adds the url key + * with the current mount point and app id. + * Object may be a single object or list of REST-format objects. + */ + expandFilesInObject(config, object) { + if (object instanceof Array) { + object.map(obj => this.expandFilesInObject(config, obj)); + return; + } + if (typeof object !== 'object') { + return; + } + for (const key in object) { + const fileObject = object[key]; + if (fileObject && fileObject['__type'] === 'File') { + if (fileObject['url']) { + continue; + } + const filename = fileObject['name']; + // all filenames starting with "tfss-" should be from files.parsetfss.com + // all filenames starting with a "-" seperated UUID should be from files.parse.com + // all other filenames have been migrated or created from Parse Server + if (config.fileKey === undefined) { + fileObject['url'] = this.adapter.getFileLocation(config, filename); + } else { + if (filename.indexOf('tfss-') === 0) { + fileObject['url'] = 'http://files.parsetfss.com/' + config.fileKey + '/' + encodeURIComponent(filename); + } else if (legacyFilesRegex.test(filename)) { + fileObject['url'] = 'http://files.parse.com/' + config.fileKey + '/' + encodeURIComponent(filename); + } else { + fileObject['url'] = this.adapter.getFileLocation(config, filename); + } + } + } + } + } + + expectedAdapterType() { + return _FilesAdapter.FilesAdapter; + } + + getFileStream(config, filename) { + return this.adapter.getFileStream(filename); + } +} + +exports.FilesController = FilesController; +exports.default = FilesController; \ No newline at end of file diff --git a/lib/Controllers/HooksController.js b/lib/Controllers/HooksController.js new file mode 100644 index 0000000000..94a9fa8054 --- /dev/null +++ b/lib/Controllers/HooksController.js @@ -0,0 +1,237 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.HooksController = undefined; + +var _triggers = require("../triggers"); + +var triggers = _interopRequireWildcard(_triggers); + +var _node = require("parse/node"); + +var Parse = _interopRequireWildcard(_node); + +var _request = require("request"); + +var request = _interopRequireWildcard(_request); + +var _logger = require("../logger"); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +/** weak */ + +const DefaultHooksCollectionName = "_Hooks"; + +class HooksController { + + constructor(applicationId, databaseController, webhookKey) { + this._applicationId = applicationId; + this._webhookKey = webhookKey; + this.database = databaseController; + } + + load() { + return this._getHooks().then(hooks => { + hooks = hooks || []; + hooks.forEach(hook => { + this.addHookToTriggers(hook); + }); + }); + } + + getFunction(functionName) { + return this._getHooks({ functionName: functionName }, 1).then(results => results[0]); + } + + getFunctions() { + return this._getHooks({ functionName: { $exists: true } }); + } + + getTrigger(className, triggerName) { + return this._getHooks({ className: className, triggerName: triggerName }, 1).then(results => results[0]); + } + + getTriggers() { + return this._getHooks({ className: { $exists: true }, triggerName: { $exists: true } }); + } + + deleteFunction(functionName) { + triggers.removeFunction(functionName, this._applicationId); + return this._removeHooks({ functionName: functionName }); + } + + deleteTrigger(className, triggerName) { + triggers.removeTrigger(triggerName, className, this._applicationId); + return this._removeHooks({ className: className, triggerName: triggerName }); + } + + _getHooks(query = {}) { + return this.database.find(DefaultHooksCollectionName, query).then(results => { + return results.map(result => { + delete result.objectId; + return result; + }); + }); + } + + _removeHooks(query) { + return this.database.destroy(DefaultHooksCollectionName, query).then(() => { + return Promise.resolve({}); + }); + } + + saveHook(hook) { + var query; + if (hook.functionName && hook.url) { + query = { functionName: hook.functionName }; + } else if (hook.triggerName && hook.className && hook.url) { + query = { className: hook.className, triggerName: hook.triggerName }; + } else { + throw new Parse.Error(143, "invalid hook declaration"); + } + return this.database.update(DefaultHooksCollectionName, query, hook, { upsert: true }).then(() => { + return Promise.resolve(hook); + }); + } + + addHookToTriggers(hook) { + var wrappedFunction = wrapToHTTPRequest(hook, this._webhookKey); + wrappedFunction.url = hook.url; + if (hook.className) { + triggers.addTrigger(hook.triggerName, hook.className, wrappedFunction, this._applicationId); + } else { + triggers.addFunction(hook.functionName, wrappedFunction, null, this._applicationId); + } + } + + addHook(hook) { + this.addHookToTriggers(hook); + return this.saveHook(hook); + } + + createOrUpdateHook(aHook) { + var hook; + if (aHook && aHook.functionName && aHook.url) { + hook = {}; + hook.functionName = aHook.functionName; + hook.url = aHook.url; + } else if (aHook && aHook.className && aHook.url && aHook.triggerName && triggers.Types[aHook.triggerName]) { + hook = {}; + hook.className = aHook.className; + hook.url = aHook.url; + hook.triggerName = aHook.triggerName; + } else { + throw new Parse.Error(143, "invalid hook declaration"); + } + + return this.addHook(hook); + } + + createHook(aHook) { + if (aHook.functionName) { + return this.getFunction(aHook.functionName).then(result => { + if (result) { + throw new Parse.Error(143, `function name: ${aHook.functionName} already exits`); + } else { + return this.createOrUpdateHook(aHook); + } + }); + } else if (aHook.className && aHook.triggerName) { + return this.getTrigger(aHook.className, aHook.triggerName).then(result => { + if (result) { + throw new Parse.Error(143, `class ${aHook.className} already has trigger ${aHook.triggerName}`); + } + return this.createOrUpdateHook(aHook); + }); + } + + throw new Parse.Error(143, "invalid hook declaration"); + } + + updateHook(aHook) { + if (aHook.functionName) { + return this.getFunction(aHook.functionName).then(result => { + if (result) { + return this.createOrUpdateHook(aHook); + } + throw new Parse.Error(143, `no function named: ${aHook.functionName} is defined`); + }); + } else if (aHook.className && aHook.triggerName) { + return this.getTrigger(aHook.className, aHook.triggerName).then(result => { + if (result) { + return this.createOrUpdateHook(aHook); + } + throw new Parse.Error(143, `class ${aHook.className} does not exist`); + }); + } + throw new Parse.Error(143, "invalid hook declaration"); + } +} + +exports.HooksController = HooksController; +function wrapToHTTPRequest(hook, key) { + return (req, res) => { + const jsonBody = {}; + for (var i in req) { + jsonBody[i] = req[i]; + } + if (req.object) { + jsonBody.object = req.object.toJSON(); + jsonBody.object.className = req.object.className; + } + if (req.original) { + jsonBody.original = req.original.toJSON(); + jsonBody.original.className = req.original.className; + } + const jsonRequest = { + headers: { + 'Content-Type': 'application/json' + }, + body: JSON.stringify(jsonBody) + }; + + if (key) { + jsonRequest.headers['X-Parse-Webhook-Key'] = key; + } else { + _logger.logger.warn('Making outgoing webhook request without webhookKey being set!'); + } + + request.post(hook.url, jsonRequest, function (err, httpResponse, body) { + var result; + if (body) { + if (typeof body === "string") { + try { + body = JSON.parse(body); + } catch (e) { + err = { + error: "Malformed response", + code: -1, + partialResponse: body.substring(0, 100) + }; + } + } + if (!err) { + result = body.success; + err = body.error; + } + } + + if (err) { + return res.error(err); + } else if (hook.triggerName === 'beforeSave') { + if (typeof result === 'object') { + delete result.createdAt; + delete result.updatedAt; + } + return res.success({ object: result }); + } else { + return res.success(result); + } + }); + }; +} + +exports.default = HooksController; \ No newline at end of file diff --git a/lib/Controllers/LiveQueryController.js b/lib/Controllers/LiveQueryController.js new file mode 100644 index 0000000000..7ccd287d5e --- /dev/null +++ b/lib/Controllers/LiveQueryController.js @@ -0,0 +1,58 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.LiveQueryController = undefined; + +var _ParseCloudCodePublisher = require('../LiveQuery/ParseCloudCodePublisher'); + +var _Options = require('../Options'); + +class LiveQueryController { + + constructor(config) { + // If config is empty, we just assume no classs needs to be registered as LiveQuery + if (!config || !config.classNames) { + this.classNames = new Set(); + } else if (config.classNames instanceof Array) { + this.classNames = new Set(config.classNames); + } else { + throw 'liveQuery.classes should be an array of string'; + } + this.liveQueryPublisher = new _ParseCloudCodePublisher.ParseCloudCodePublisher(config); + } + + onAfterSave(className, currentObject, originalObject) { + if (!this.hasLiveQuery(className)) { + return; + } + const req = this._makePublisherRequest(currentObject, originalObject); + this.liveQueryPublisher.onCloudCodeAfterSave(req); + } + + onAfterDelete(className, currentObject, originalObject) { + if (!this.hasLiveQuery(className)) { + return; + } + const req = this._makePublisherRequest(currentObject, originalObject); + this.liveQueryPublisher.onCloudCodeAfterDelete(req); + } + + hasLiveQuery(className) { + return this.classNames.has(className); + } + + _makePublisherRequest(currentObject, originalObject) { + const req = { + object: currentObject + }; + if (currentObject) { + req.original = originalObject; + } + return req; + } +} + +exports.LiveQueryController = LiveQueryController; +exports.default = LiveQueryController; \ No newline at end of file diff --git a/lib/Controllers/LoggerController.js b/lib/Controllers/LoggerController.js new file mode 100644 index 0000000000..cafd1825ae --- /dev/null +++ b/lib/Controllers/LoggerController.js @@ -0,0 +1,243 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.LoggerController = exports.LogOrder = exports.LogLevel = undefined; + +var _node = require('parse/node'); + +var _AdaptableController = require('./AdaptableController'); + +var _AdaptableController2 = _interopRequireDefault(_AdaptableController); + +var _LoggerAdapter = require('../Adapters/Logger/LoggerAdapter'); + +var _url = require('url'); + +var _url2 = _interopRequireDefault(_url); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const MILLISECONDS_IN_A_DAY = 24 * 60 * 60 * 1000; +const LOG_STRING_TRUNCATE_LENGTH = 1000; +const truncationMarker = '... (truncated)'; + +const LogLevel = exports.LogLevel = { + INFO: 'info', + ERROR: 'error' +}; + +const LogOrder = exports.LogOrder = { + DESCENDING: 'desc', + ASCENDING: 'asc' +}; + +const logLevels = ['error', 'warn', 'info', 'debug', 'verbose', 'silly']; + +class LoggerController extends _AdaptableController2.default { + + constructor(adapter, appId, options = { logLevel: 'info' }) { + super(adapter, appId, options); + let level = 'info'; + if (options.verbose) { + level = 'verbose'; + } + if (options.logLevel) { + level = options.logLevel; + } + const index = logLevels.indexOf(level); // info by default + logLevels.forEach((level, levelIndex) => { + if (levelIndex > index) { + // silence the levels that are > maxIndex + this[level] = () => {}; + } + }); + } + + maskSensitiveUrl(urlString) { + const password = _url2.default.parse(urlString, true).query.password; + + if (password) { + urlString = urlString.replace('password=' + password, 'password=********'); + } + return urlString; + } + + maskSensitive(argArray) { + return argArray.map(e => { + if (!e) { + return e; + } + + if (typeof e === 'string') { + return e.replace(/(password".?:.?")[^"]*"/g, '$1********"'); + } + // else it is an object... + + // check the url + if (e.url) { + // for strings + if (typeof e.url === 'string') { + e.url = this.maskSensitiveUrl(e.url); + } else if (Array.isArray(e.url)) { + // for strings in array + e.url = e.url.map(item => { + if (typeof item === 'string') { + return this.maskSensitiveUrl(item); + } + + return item; + }); + } + } + + if (e.body) { + for (const key of Object.keys(e.body)) { + if (key === 'password') { + e.body[key] = '********'; + break; + } + } + } + + if (e.params) { + for (const key of Object.keys(e.params)) { + if (key === 'password') { + e.params[key] = '********'; + break; + } + } + } + + return e; + }); + } + + log(level, args) { + // make the passed in arguments object an array with the spread operator + args = this.maskSensitive([...args]); + args = [].concat(level, args.map(arg => { + if (typeof arg === 'function') { + return arg(); + } + return arg; + })); + this.adapter.log.apply(this.adapter, args); + } + + info() { + return this.log('info', arguments); + } + + error() { + return this.log('error', arguments); + } + + warn() { + return this.log('warn', arguments); + } + + verbose() { + return this.log('verbose', arguments); + } + + debug() { + return this.log('debug', arguments); + } + + silly() { + return this.log('silly', arguments); + } + + logRequest({ + method, + url, + headers, + body + }) { + this.verbose(() => { + const stringifiedBody = JSON.stringify(body, null, 2); + return `REQUEST for [${method}] ${url}: ${stringifiedBody}`; + }, { + method, + url, + headers, + body + }); + } + + logResponse({ + method, + url, + result + }) { + this.verbose(() => { + const stringifiedResponse = JSON.stringify(result, null, 2); + return `RESPONSE from [${method}] ${url}: ${stringifiedResponse}`; + }, { result: result }); + } + // check that date input is valid + static validDateTime(date) { + if (!date) { + return null; + } + date = new Date(date); + + if (!isNaN(date.getTime())) { + return date; + } + + return null; + } + + truncateLogMessage(string) { + if (string && string.length > LOG_STRING_TRUNCATE_LENGTH) { + const truncated = string.substring(0, LOG_STRING_TRUNCATE_LENGTH) + truncationMarker; + return truncated; + } + + return string; + } + + static parseOptions(options = {}) { + const from = LoggerController.validDateTime(options.from) || new Date(Date.now() - 7 * MILLISECONDS_IN_A_DAY); + const until = LoggerController.validDateTime(options.until) || new Date(); + const size = Number(options.size) || 10; + const order = options.order || LogOrder.DESCENDING; + const level = options.level || LogLevel.INFO; + + return { + from, + until, + size, + order, + level + }; + } + + // Returns a promise for a {response} object. + // query params: + // level (optional) Level of logging you want to query for (info || error) + // from (optional) Start time for the search. Defaults to 1 week ago. + // until (optional) End time for the search. Defaults to current time. + // order (optional) Direction of results returned, either “asc” or “desc”. Defaults to “desc”. + // size (optional) Number of rows returned by search. Defaults to 10 + getLogs(options = {}) { + if (!this.adapter) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Logger adapter is not available'); + } + if (typeof this.adapter.query !== 'function') { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Querying logs is not supported with this adapter'); + } + options = LoggerController.parseOptions(options); + return this.adapter.query(options); + } + + expectedAdapterType() { + return _LoggerAdapter.LoggerAdapter; + } +} + +exports.LoggerController = LoggerController; +exports.default = LoggerController; \ No newline at end of file diff --git a/lib/Controllers/PushController.js b/lib/Controllers/PushController.js new file mode 100644 index 0000000000..89599094ba --- /dev/null +++ b/lib/Controllers/PushController.js @@ -0,0 +1,212 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PushController = undefined; + +var _node = require('parse/node'); + +var _RestQuery = require('../RestQuery'); + +var _RestQuery2 = _interopRequireDefault(_RestQuery); + +var _RestWrite = require('../RestWrite'); + +var _RestWrite2 = _interopRequireDefault(_RestWrite); + +var _Auth = require('../Auth'); + +var _StatusHandler = require('../StatusHandler'); + +var _utils = require('../Push/utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class PushController { + + sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) { + if (!config.hasPushSupport) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Missing push configuration'); + } + + // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time + body.expiration_time = PushController.getExpirationTime(body); + body.expiration_interval = PushController.getExpirationInterval(body); + if (body.expiration_time && body.expiration_interval) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Both expiration_time and expiration_interval cannot be set'); + } + + // Immediate push + if (body.expiration_interval && !body.hasOwnProperty('push_time')) { + const ttlMs = body.expiration_interval * 1000; + body.expiration_time = new Date(now.valueOf() + ttlMs).valueOf(); + } + + const pushTime = PushController.getPushTime(body); + if (pushTime && pushTime.date !== 'undefined') { + body['push_time'] = PushController.formatPushTime(pushTime); + } + + // TODO: If the req can pass the checking, we return immediately instead of waiting + // pushes to be sent. We probably change this behaviour in the future. + let badgeUpdate = () => { + return Promise.resolve(); + }; + + if (body.data && body.data.badge) { + const badge = body.data.badge; + let restUpdate = {}; + if (typeof badge == 'string' && badge.toLowerCase() === 'increment') { + restUpdate = { badge: { __op: 'Increment', amount: 1 } }; + } else if (Number(badge)) { + restUpdate = { badge: badge }; + } else { + throw "Invalid value for badge, expected number or 'Increment'"; + } + + // Force filtering on only valid device tokens + const updateWhere = (0, _utils.applyDeviceTokenExists)(where); + badgeUpdate = () => { + // Build a real RestQuery so we can use it in RestWrite + const restQuery = new _RestQuery2.default(config, (0, _Auth.master)(config), '_Installation', updateWhere); + return restQuery.buildRestWhere().then(() => { + const write = new _RestWrite2.default(config, (0, _Auth.master)(config), '_Installation', restQuery.restWhere, restUpdate); + write.runOptions.many = true; + return write.execute(); + }); + }; + } + const pushStatus = (0, _StatusHandler.pushStatusHandler)(config); + return Promise.resolve().then(() => { + return pushStatus.setInitial(body, where); + }).then(() => { + onPushStatusSaved(pushStatus.objectId); + return badgeUpdate(); + }).then(() => { + // Update audience lastUsed and timesUsed + if (body.audience_id) { + const audienceId = body.audience_id; + + var updateAudience = { + lastUsed: { __type: "Date", iso: new Date().toISOString() }, + timesUsed: { __op: "Increment", "amount": 1 } + }; + const write = new _RestWrite2.default(config, (0, _Auth.master)(config), '_Audience', { objectId: audienceId }, updateAudience); + write.execute(); + } + // Don't wait for the audience update promise to resolve. + return Promise.resolve(); + }).then(() => { + if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) { + return Promise.resolve(); + } + return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus); + }).catch(err => { + return pushStatus.fail(err).then(() => { + throw err; + }); + }); + } + + /** + * Get expiration time from the request body. + * @param {Object} request A request object + * @returns {Number|undefined} The expiration time if it exists in the request + */ + static getExpirationTime(body = {}) { + var hasExpirationTime = body.hasOwnProperty('expiration_time'); + if (!hasExpirationTime) { + return; + } + var expirationTimeParam = body['expiration_time']; + var expirationTime; + if (typeof expirationTimeParam === 'number') { + expirationTime = new Date(expirationTimeParam * 1000); + } else if (typeof expirationTimeParam === 'string') { + expirationTime = new Date(expirationTimeParam); + } else { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, body['expiration_time'] + ' is not valid time.'); + } + // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN + if (!isFinite(expirationTime)) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, body['expiration_time'] + ' is not valid time.'); + } + return expirationTime.valueOf(); + } + + static getExpirationInterval(body = {}) { + const hasExpirationInterval = body.hasOwnProperty('expiration_interval'); + if (!hasExpirationInterval) { + return; + } + + var expirationIntervalParam = body['expiration_interval']; + if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, `expiration_interval must be a number greater than 0`); + } + return expirationIntervalParam; + } + + /** + * Get push time from the request body. + * @param {Object} request A request object + * @returns {Number|undefined} The push time if it exists in the request + */ + static getPushTime(body = {}) { + var hasPushTime = body.hasOwnProperty('push_time'); + if (!hasPushTime) { + return; + } + var pushTimeParam = body['push_time']; + var date; + var isLocalTime = true; + + if (typeof pushTimeParam === 'number') { + date = new Date(pushTimeParam * 1000); + } else if (typeof pushTimeParam === 'string') { + isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam); + date = new Date(pushTimeParam); + } else { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, body['push_time'] + ' is not valid time.'); + } + // Check pushTime is valid or not, if it is not valid, pushTime is NaN + if (!isFinite(date)) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, body['push_time'] + ' is not valid time.'); + } + + return { + date, + isLocalTime + }; + } + + /** + * Checks if a ISO8601 formatted date contains a timezone component + * @param pushTimeParam {string} + * @returns {boolean} + */ + static pushTimeHasTimezoneComponent(pushTimeParam) { + const offsetPattern = /(.+)([+-])\d\d:\d\d$/; + return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z + || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00 + } + + /** + * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true + * @param date {Date} + * @param isLocalTime {boolean} + * @returns {string} + */ + static formatPushTime({ date, isLocalTime }) { + if (isLocalTime) { + // Strip 'Z' + const isoString = date.toISOString(); + return isoString.substring(0, isoString.indexOf('Z')); + } + return date.toISOString(); + } +} + +exports.PushController = PushController; +exports.default = PushController; \ No newline at end of file diff --git a/lib/Controllers/SchemaCache.js b/lib/Controllers/SchemaCache.js new file mode 100644 index 0000000000..67982c4287 --- /dev/null +++ b/lib/Controllers/SchemaCache.js @@ -0,0 +1,96 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _cryptoUtils = require("../cryptoUtils"); + +var _defaults = require("../defaults"); + +var _defaults2 = _interopRequireDefault(_defaults); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const MAIN_SCHEMA = "__MAIN_SCHEMA"; +const SCHEMA_CACHE_PREFIX = "__SCHEMA"; +const ALL_KEYS = "__ALL_KEYS"; + +class SchemaCache { + + constructor(cacheController, ttl = _defaults2.default.schemaCacheTTL, singleCache = false) { + this.ttl = ttl; + if (typeof ttl == 'string') { + this.ttl = parseInt(ttl); + } + this.cache = cacheController; + this.prefix = SCHEMA_CACHE_PREFIX; + if (!singleCache) { + this.prefix += (0, _cryptoUtils.randomString)(20); + } + } + + put(key, value) { + 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)]); + }); + } + + getAllClasses() { + if (!this.ttl) { + return Promise.resolve(null); + } + return this.cache.get(this.prefix + MAIN_SCHEMA); + } + + setAllClasses(schema) { + if (!this.ttl) { + return Promise.resolve(null); + } + return this.put(this.prefix + MAIN_SCHEMA, schema); + } + + setOneSchema(className, schema) { + if (!this.ttl) { + return Promise.resolve(null); + } + return this.put(this.prefix + className, schema); + } + + getOneSchema(className) { + if (!this.ttl) { + return Promise.resolve(null); + } + return this.cache.get(this.prefix + className).then(schema => { + if (schema) { + return Promise.resolve(schema); + } + return this.cache.get(this.prefix + MAIN_SCHEMA).then(cachedSchemas => { + cachedSchemas = cachedSchemas || []; + schema = cachedSchemas.find(cachedSchema => { + return cachedSchema.className === className; + }); + if (schema) { + return Promise.resolve(schema); + } + return Promise.resolve(null); + }); + }); + } + + clear() { + // That clears all caches... + return this.cache.get(this.prefix + ALL_KEYS).then(allKeys => { + if (!allKeys) { + return; + } + const promises = Object.keys(allKeys).map(key => { + return this.cache.del(key); + }); + return Promise.all(promises); + }); + } +} +exports.default = SchemaCache; \ No newline at end of file diff --git a/lib/Controllers/SchemaController.js b/lib/Controllers/SchemaController.js new file mode 100644 index 0000000000..643956669f --- /dev/null +++ b/lib/Controllers/SchemaController.js @@ -0,0 +1,1048 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + +// This class handles schema validation, persistence, and modification. +// +// Each individual Schema object should be immutable. The helpers to +// do things with the Schema just return a new schema when the schema +// is changed. +// +// The canonical place to store this Schema is in the database itself, +// in a _SCHEMA collection. This is not the right way to do it for an +// open source framework, but it's backward compatible, so we're +// keeping it this way for now. +// +// In API-handling code, you should only use the Schema class via the +// DatabaseController. This will let us replace the schema logic for +// different databases. +// TODO: hide all schema logic inside the database adapter. +const Parse = require('parse/node').Parse; + +const defaultColumns = Object.freeze({ + // Contain the default columns for every parse object type (except _Join collection) + _Default: { + "objectId": { type: 'String' }, + "createdAt": { type: 'Date' }, + "updatedAt": { type: 'Date' }, + "ACL": { type: 'ACL' } + }, + // The additional default columns for the _User collection (in addition to DefaultCols) + _User: { + "username": { type: 'String' }, + "password": { type: 'String' }, + "email": { type: 'String' }, + "emailVerified": { type: 'Boolean' }, + "authData": { type: 'Object' } + }, + // The additional default columns for the _Installation collection (in addition to DefaultCols) + _Installation: { + "installationId": { type: 'String' }, + "deviceToken": { type: 'String' }, + "channels": { type: 'Array' }, + "deviceType": { type: 'String' }, + "pushType": { type: 'String' }, + "GCMSenderId": { type: 'String' }, + "timeZone": { type: 'String' }, + "localeIdentifier": { type: 'String' }, + "badge": { type: 'Number' }, + "appVersion": { type: 'String' }, + "appName": { type: 'String' }, + "appIdentifier": { type: 'String' }, + "parseVersion": { type: 'String' } + }, + // The additional default columns for the _Role collection (in addition to DefaultCols) + _Role: { + "name": { type: 'String' }, + "users": { type: 'Relation', targetClass: '_User' }, + "roles": { type: 'Relation', targetClass: '_Role' } + }, + // The additional default columns for the _Session collection (in addition to DefaultCols) + _Session: { + "restricted": { type: 'Boolean' }, + "user": { type: 'Pointer', targetClass: '_User' }, + "installationId": { type: 'String' }, + "sessionToken": { type: 'String' }, + "expiresAt": { type: 'Date' }, + "createdWith": { type: 'Object' } + }, + _Product: { + "productIdentifier": { type: 'String' }, + "download": { type: 'File' }, + "downloadName": { type: 'String' }, + "icon": { type: 'File' }, + "order": { type: 'Number' }, + "title": { type: 'String' }, + "subtitle": { type: 'String' } + }, + _PushStatus: { + "pushTime": { type: 'String' }, + "source": { type: 'String' }, // rest or webui + "query": { type: 'String' }, // the stringified JSON query + "payload": { type: 'String' }, // the stringified JSON payload, + "title": { type: 'String' }, + "expiry": { type: 'Number' }, + "expiration_interval": { type: 'Number' }, + "status": { type: 'String' }, + "numSent": { type: 'Number' }, + "numFailed": { type: 'Number' }, + "pushHash": { type: 'String' }, + "errorMessage": { type: 'Object' }, + "sentPerType": { type: 'Object' }, + "failedPerType": { type: 'Object' }, + "sentPerUTCOffset": { type: 'Object' }, + "failedPerUTCOffset": { type: 'Object' }, + "count": { type: 'Number' // tracks # of batches queued and pending + } }, + _JobStatus: { + "jobName": { type: 'String' }, + "source": { type: 'String' }, + "status": { type: 'String' }, + "message": { type: 'String' }, + "params": { type: 'Object' }, // params received when calling the job + "finishedAt": { type: 'Date' } + }, + _JobSchedule: { + "jobName": { type: 'String' }, + "description": { type: 'String' }, + "params": { type: 'String' }, + "startAfter": { type: 'String' }, + "daysOfWeek": { type: 'Array' }, + "timeOfDay": { type: 'String' }, + "lastRun": { type: 'Number' }, + "repeatMinutes": { type: 'Number' } + }, + _Hooks: { + "functionName": { type: 'String' }, + "className": { type: 'String' }, + "triggerName": { type: 'String' }, + "url": { type: 'String' } + }, + _GlobalConfig: { + "objectId": { type: 'String' }, + "params": { type: 'Object' } + }, + _Audience: { + "objectId": { type: 'String' }, + "name": { type: 'String' }, + "query": { type: 'String' }, //storing query as JSON string to prevent "Nested keys should not contain the '$' or '.' characters" error + "lastUsed": { type: 'Date' }, + "timesUsed": { type: 'Number' } + }, + _ExportProgress: { + "objectId": { type: 'String' }, + "id": { type: 'String' }, + "masterKey": { type: 'String' }, + "applicationId": { type: 'String' } + } +}); + +const requiredColumns = Object.freeze({ + _Product: ["productIdentifier", "icon", "order", "title", "subtitle"], + _Role: ["name", "ACL"] +}); + +const systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience', '_ExportProgress']); + +const volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule', '_Audience', '_ExportProgress']); + +// 10 alpha numberic chars + uppercase +const userIdRegex = /^[a-zA-Z0-9]{10}$/; +// Anything that start with role +const roleRegex = /^role:.*/; +// * permission +const publicRegex = /^\*$/; + +const requireAuthenticationRegex = /^requiresAuthentication$/; + +const permissionKeyRegex = Object.freeze([userIdRegex, roleRegex, publicRegex, requireAuthenticationRegex]); + +function verifyPermissionKey(key) { + const result = permissionKeyRegex.reduce((isGood, regEx) => { + isGood = isGood || key.match(regEx) != null; + return isGood; + }, false); + if (!result) { + throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid key for class level permissions`); + } +} + +const CLPValidKeys = Object.freeze(['find', 'count', 'get', 'create', 'update', 'delete', 'addField', 'readUserFields', 'writeUserFields']); +function validateCLP(perms, fields) { + if (!perms) { + return; + } + Object.keys(perms).forEach(operation => { + if (CLPValidKeys.indexOf(operation) == -1) { + throw new Parse.Error(Parse.Error.INVALID_JSON, `${operation} is not a valid operation for class level permissions`); + } + + if (operation === 'readUserFields' || operation === 'writeUserFields') { + if (!Array.isArray(perms[operation])) { + throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perms[operation]}' is not a valid value for class level permissions ${operation}`); + } 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}`); + } + }); + } + return; + } + + Object.keys(perms[operation]).forEach(key => { + verifyPermissionKey(key); + const perm = perms[operation][key]; + if (perm !== true) { + throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perm}' is not a valid value for class level permissions ${operation}:${key}:${perm}`); + } + }); + }); +} +const joinClassRegex = /^_Join:[A-Za-z0-9_]+:[A-Za-z0-9_]+/; +const classAndFieldRegex = /^[A-Za-z][A-Za-z0-9_]*$/; +function classNameIsValid(className) { + // Valid classes must: + return ( + // Be one of _User, _Installation, _Role, _Session OR + systemClasses.indexOf(className) > -1 || + // Be a join table OR + joinClassRegex.test(className) || + // Include only alpha-numeric and underscores, and not start with an underscore or number + fieldNameIsValid(className) + ); +} + +// Valid fields must be alpha-numeric, and not start with an underscore or number +function fieldNameIsValid(fieldName) { + return classAndFieldRegex.test(fieldName); +} + +// Checks that it's not trying to clobber one of the default fields of the class. +function fieldNameIsValidForClass(fieldName, className) { + if (!fieldNameIsValid(fieldName)) { + return false; + } + if (defaultColumns._Default[fieldName]) { + return false; + } + if (defaultColumns[className] && defaultColumns[className][fieldName]) { + return false; + } + return true; +} + +function invalidClassNameMessage(className) { + return 'Invalid classname: ' + className + ', classnames can only have alphanumeric characters and _, and must start with an alpha character '; +} + +const invalidJsonError = new Parse.Error(Parse.Error.INVALID_JSON, "invalid JSON"); +const validNonRelationOrPointerTypes = ['Number', 'String', 'Boolean', 'Date', 'Object', 'Array', 'GeoPoint', 'File', 'Bytes', 'Polygon']; +// Returns an error suitable for throwing if the type is invalid +const fieldTypeIsInvalid = ({ type, targetClass }) => { + if (['Pointer', 'Relation'].indexOf(type) >= 0) { + if (!targetClass) { + return new Parse.Error(135, `type ${type} needs a class name`); + } else if (typeof targetClass !== 'string') { + return invalidJsonError; + } else if (!classNameIsValid(targetClass)) { + return new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(targetClass)); + } else { + return undefined; + } + } + 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; +}; + +const convertSchemaToAdapterSchema = schema => { + schema = injectDefaultSchema(schema); + delete schema.fields.ACL; + schema.fields._rperm = { type: 'Array' }; + schema.fields._wperm = { type: 'Array' }; + + if (schema.className === '_User') { + delete schema.fields.password; + schema.fields._hashed_password = { type: 'String' }; + } + + return schema; +}; + +const convertAdapterSchemaToParseSchema = (_ref) => { + let schema = _objectWithoutProperties(_ref, []); + + delete schema.fields._rperm; + delete schema.fields._wperm; + + schema.fields.ACL = { type: 'ACL' }; + + if (schema.className === '_User') { + delete schema.fields.authData; //Auth data is implicit + delete schema.fields._hashed_password; + schema.fields.password = { type: 'String' }; + } + + if (schema.indexes && Object.keys(schema.indexes).length === 0) { + delete schema.indexes; + } + + return schema; +}; + +const injectDefaultSchema = ({ className, fields, classLevelPermissions, indexes }) => { + const defaultSchema = { + className, + fields: _extends({}, defaultColumns._Default, defaultColumns[className] || {}, fields), + classLevelPermissions + }; + if (indexes && Object.keys(indexes).length !== 0) { + defaultSchema.indexes = indexes; + } + return defaultSchema; +}; + +const _HooksSchema = { className: "_Hooks", fields: defaultColumns._Hooks }; +const _GlobalConfigSchema = { className: "_GlobalConfig", fields: defaultColumns._GlobalConfig }; +const _PushStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({ + className: "_PushStatus", + fields: {}, + classLevelPermissions: {} +})); +const _JobStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({ + className: "_JobStatus", + fields: {}, + classLevelPermissions: {} +})); +const _JobScheduleSchema = convertSchemaToAdapterSchema(injectDefaultSchema({ + className: "_JobSchedule", + fields: {}, + classLevelPermissions: {} +})); +const _AudienceSchema = convertSchemaToAdapterSchema(injectDefaultSchema({ + className: "_Audience", + fields: defaultColumns._Audience +})); +const VolatileClassesSchemas = [_HooksSchema, _JobStatusSchema, _JobScheduleSchema, _PushStatusSchema, _GlobalConfigSchema, _AudienceSchema]; + +const dbTypeMatchesObjectType = (dbType, objectType) => { + if (dbType.type !== objectType.type) return false; + if (dbType.targetClass !== objectType.targetClass) return false; + if (dbType === objectType.type) return true; + if (dbType.type === objectType.type) return true; + return false; +}; + +const typeToString = type => { + if (type.targetClass) { + return `${type.type}<${type.targetClass}>`; + } + return `${type.type || type}`; +}; + +// Stores the entire schema of the app in a weird hybrid format somewhere between +// the mongo format and the Parse format. Soon, this will all be Parse format. +class SchemaController { + + constructor(databaseAdapter, schemaCache) { + this._dbAdapter = databaseAdapter; + this._cache = schemaCache; + // this.data[className][fieldName] tells you the type of that field, in mongo format + this.data = {}; + // this.perms[className][operation] tells you the acl-style permissions + this.perms = {}; + // this.indexes[className][operation] tells you the indexes + this.indexes = {}; + } + + reloadData(options = { clearCache: false }) { + let promise = Promise.resolve(); + if (options.clearCache) { + promise = promise.then(() => { + return this._cache.clear(); + }); + } + if (this.reloadDataPromise && !options.clearCache) { + return this.reloadDataPromise; + } + this.reloadDataPromise = promise.then(() => { + return this.getAllClasses(options); + }).then(allSchemas => { + const data = {}; + const perms = {}; + const indexes = {}; + allSchemas.forEach(schema => { + data[schema.className] = injectDefaultSchema(schema).fields; + perms[schema.className] = schema.classLevelPermissions; + indexes[schema.className] = schema.indexes; + }); + + // Inject the in-memory classes + volatileClasses.forEach(className => { + const schema = injectDefaultSchema({ className }); + data[className] = schema.fields; + perms[className] = schema.classLevelPermissions; + indexes[className] = schema.indexes; + }); + this.data = data; + this.perms = perms; + this.indexes = indexes; + delete this.reloadDataPromise; + }, err => { + this.data = {}; + this.perms = {}; + this.indexes = {}; + delete this.reloadDataPromise; + throw err; + }); + return this.reloadDataPromise; + } + + getAllClasses(options = { clearCache: false }) { + let promise = Promise.resolve(); + if (options.clearCache) { + promise = this._cache.clear(); + } + 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 allSchemas; + }); + }); + }); + } + + getOneSchema(className, allowVolatileClasses = false, options = { clearCache: false }) { + let promise = Promise.resolve(); + if (options.clearCache) { + promise = this._cache.clear(); + } + return promise.then(() => { + if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) { + return Promise.resolve({ + className, + fields: this.data[className], + classLevelPermissions: this.perms[className], + indexes: this.indexes[className] + }); + } + 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(() => { + return result; + }); + }); + }); + }); + } + + // Create a new class that includes the three default fields. + // ACL is an implicit column that does not get an entry in the + // _SCHEMAS database. Returns a promise that resolves with the + // created schema, in mongo format. + // on success, and rejects with an error on fail. Ensure you + // have authorization (master key, or client class creation + // enabled) before calling this function. + addClassIfNotExists(className, fields = {}, classLevelPermissions, indexes = {}) { + var validationError = this.validateNewClass(className, fields, classLevelPermissions); + if (validationError) { + return Promise.reject(validationError); + } + + return this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({ fields, classLevelPermissions, indexes, className })).then(convertAdapterSchemaToParseSchema).then(res => { + return this._cache.clear().then(() => { + return Promise.resolve(res); + }); + }).catch(error => { + if (error && error.code === Parse.Error.DUPLICATE_VALUE) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`); + } else { + throw error; + } + }); + } + + updateClass(className, submittedFields, classLevelPermissions, indexes, database) { + return this.getOneSchema(className).then(schema => { + const existingFields = schema.fields; + Object.keys(submittedFields).forEach(name => { + const field = submittedFields[name]; + if (existingFields[name] && field.__op !== 'Delete') { + throw new Parse.Error(255, `Field ${name} exists, cannot update.`); + } + if (!existingFields[name] && field.__op === 'Delete') { + throw new Parse.Error(255, `Field ${name} does not exist, cannot delete.`); + } + }); + + delete existingFields._rperm; + delete existingFields._wperm; + const newSchema = buildMergedSchemaObject(existingFields, submittedFields); + const validationError = this.validateSchemaData(className, newSchema, classLevelPermissions, Object.keys(existingFields)); + if (validationError) { + throw new Parse.Error(validationError.code, validationError.error); + } + + // Finally we have checked to make sure the request is valid and we can start deleting fields. + // Do all deletions first, then a single save to _SCHEMA collection to handle all additions. + const deletedFields = []; + const insertedFields = []; + Object.keys(submittedFields).forEach(fieldName => { + if (submittedFields[fieldName].__op === 'Delete') { + deletedFields.push(fieldName); + } else { + insertedFields.push(fieldName); + } + }); + + let deletePromise = Promise.resolve(); + if (deletedFields.length > 0) { + deletePromise = this.deleteFields(deletedFields, className, database); + } + return deletePromise // Delete Everything + .then(() => this.reloadData({ clearCache: true })) // Reload our Schema, so we have all the new values + .then(() => { + const promises = insertedFields.map(fieldName => { + const type = submittedFields[fieldName]; + return this.enforceFieldExists(className, fieldName, type); + }); + return Promise.all(promises); + }).then(() => this.setPermissions(className, classLevelPermissions, newSchema)).then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, newSchema)).then(() => this.reloadData({ clearCache: true })) + //TODO: Move this logic into the database adapter + .then(() => { + const reloadedSchema = { + className: className, + fields: this.data[className], + classLevelPermissions: this.perms[className] + }; + if (this.indexes[className] && Object.keys(this.indexes[className]).length !== 0) { + reloadedSchema.indexes = this.indexes[className]; + } + return reloadedSchema; + }); + }).catch(error => { + if (error === undefined) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`); + } else { + throw error; + } + }); + } + + // Returns a promise that resolves successfully to the new schema + // object or fails with a reason. + enforceClassExists(className) { + if (this.data[className]) { + return Promise.resolve(this); + } + // We don't have this class. Update the schema + return this.addClassIfNotExists(className) + // The schema update succeeded. Reload the schema + .then(() => this.reloadData({ clearCache: true })).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. + // So just reload the schema. + return this.reloadData({ clearCache: true }); + }).then(() => { + // Ensure that the schema now validates + if (this.data[className]) { + return this; + } else { + throw new Parse.Error(Parse.Error.INVALID_JSON, `Failed to add ${className}`); + } + }).catch(() => { + // The schema still doesn't validate. Give up + throw new Parse.Error(Parse.Error.INVALID_JSON, 'schema class name does not revalidate'); + }); + } + + validateNewClass(className, fields = {}, classLevelPermissions) { + if (this.data[className]) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`); + } + if (!classNameIsValid(className)) { + return { + code: Parse.Error.INVALID_CLASS_NAME, + error: invalidClassNameMessage(className) + }; + } + return this.validateSchemaData(className, fields, classLevelPermissions, []); + } + + validateSchemaData(className, fields, classLevelPermissions, existingFieldNames) { + for (const fieldName in fields) { + if (existingFieldNames.indexOf(fieldName) < 0) { + if (!fieldNameIsValid(fieldName)) { + return { + code: Parse.Error.INVALID_KEY_NAME, + error: 'invalid field name: ' + fieldName + }; + } + if (!fieldNameIsValidForClass(fieldName, className)) { + return { + code: 136, + error: 'field ' + fieldName + ' cannot be added' + }; + } + const error = fieldTypeIsInvalid(fields[fieldName]); + if (error) return { code: error.code, error: error.message }; + } + } + + for (const fieldName in defaultColumns[className]) { + fields[fieldName] = defaultColumns[className][fieldName]; + } + + const geoPoints = Object.keys(fields).filter(key => fields[key] && fields[key].type === 'GeoPoint'); + if (geoPoints.length > 1) { + return { + code: Parse.Error.INCORRECT_TYPE, + error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.' + }; + } + validateCLP(classLevelPermissions, fields); + } + + // Sets the Class-level permissions for a given className, which must exist. + setPermissions(className, perms, newSchema) { + if (typeof perms === 'undefined') { + return Promise.resolve(); + } + validateCLP(perms, newSchema); + return this._dbAdapter.setClassLevelPermissions(className, perms); + } + + // Returns a promise that resolves successfully to the new schema + // 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) { + if (fieldName.indexOf(".") > 0) { + // subdocument key (x.y) => ok if x is of type 'object' + fieldName = fieldName.split(".")[0]; + type = 'Object'; + } + if (!fieldNameIsValid(fieldName)) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`); + } + + // If someone tries to create a new field with null/undefined as the value, return; + if (!type) { + return Promise.resolve(this); + } + + return this.reloadData().then(() => { + const expectedType = this.getExpectedType(className, fieldName); + if (typeof type === 'string') { + type = { type }; + } + + if (expectedType) { + if (!dbTypeMatchesObjectType(expectedType, type)) { + throw new Parse.Error(Parse.Error.INCORRECT_TYPE, `schema mismatch for ${className}.${fieldName}; expected ${typeToString(expectedType)} but got ${typeToString(type)}`); + } + return this; + } + + return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => { + // The update succeeded. Reload the schema + return this.reloadData({ clearCache: true }); + }, error => { + if (error.code == Parse.Error.INCORRECT_TYPE) { + // Make sure that we throw errors when it is appropriate to do so. + throw error; + } + // 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(() => { + // 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}`); + } + // Remove the cached schema + this._cache.clear(); + return this; + }); + }); + } + + // maintain compatibility + deleteField(fieldName, className, database) { + return this.deleteFields([fieldName], className, database); + } + + // Delete fields, and remove that data from all objects. This is intended + // to remove unused fields, if other writers are writing objects that include + // this field, the field may reappear. Returns a Promise that resolves with + // no object on success, or rejects with { code, error } on failure. + // Passing the database and prefix is necessary in order to drop relation collections + // and remove fields from objects. Ideally the database would belong to + // a database adapter and this function would close over it or access it via member. + deleteFields(fieldNames, className, database) { + if (!classNameIsValid(className)) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(className)); + } + + fieldNames.forEach(fieldName => { + if (!fieldNameIsValid(fieldName)) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `invalid field name: ${fieldName}`); + } + //Don't allow deleting the default fields. + if (!fieldNameIsValidForClass(fieldName, className)) { + throw new Parse.Error(136, `field ${fieldName} cannot be changed`); + } + }); + + return this.getOneSchema(className, false, { clearCache: true }).catch(error => { + if (error === undefined) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`); + } else { + throw error; + } + }).then(schema => { + fieldNames.forEach(fieldName => { + if (!schema.fields[fieldName]) { + throw new Parse.Error(255, `Field ${fieldName} does not exist, cannot delete.`); + } + }); + + const schemaFields = _extends({}, schema.fields); + return database.adapter.deleteFields(className, schema, fieldNames).then(() => { + return Promise.all(fieldNames.map(fieldName => { + const field = schemaFields[fieldName]; + if (field && field.type === 'Relation') { + //For relations, drop the _Join table + return database.adapter.deleteClass(`_Join:${fieldName}:${className}`); + } + return Promise.resolve(); + })); + }); + }).then(() => { + this._cache.clear(); + }); + } + + // Validates an object provided in REST format. + // Returns a promise that resolves to the new schema if this object is + // valid. + validateObject(className, object, query) { + let geocount = 0; + let promise = this.enforceClassExists(className); + for (const fieldName in object) { + if (object[fieldName] === undefined) { + continue; + } + const expected = getType(object[fieldName]); + if (expected === 'GeoPoint') { + geocount++; + } + if (geocount > 1) { + // Make sure all field validation operations run before we return. + // If not - we are continuing to run logic, but already provided response from the server. + return promise.then(() => { + return Promise.reject(new Parse.Error(Parse.Error.INCORRECT_TYPE, 'there can only be one geopoint field in a class')); + }); + } + if (!expected) { + continue; + } + if (fieldName === 'ACL') { + // Every object has ACL implicitly. + continue; + } + + promise = promise.then(schema => schema.enforceFieldExists(className, fieldName, expected)); + } + promise = thenValidateRequiredColumns(promise, className, object, query); + return promise; + } + + // Validates that all the properties are set for the object + validateRequiredColumns(className, object, query) { + const columns = requiredColumns[className]; + if (!columns || columns.length == 0) { + return Promise.resolve(this); + } + + const missingColumns = columns.filter(function (column) { + if (query && query.objectId) { + if (object[column] && typeof object[column] === "object") { + // Trying to delete a required column + return object[column].__op == 'Delete'; + } + // Not trying to do anything there + return false; + } + return !object[column]; + }); + + if (missingColumns.length > 0) { + throw new Parse.Error(Parse.Error.INCORRECT_TYPE, missingColumns[0] + ' is required.'); + } + return Promise.resolve(this); + } + + // Validates the base CLP for an operation + testBaseCLP(className, aclGroup, operation) { + if (!this.perms[className] || !this.perms[className][operation]) { + return true; + } + const classPerms = this.perms[className]; + const perms = classPerms[operation]; + // Handle the public scenario quickly + if (perms['*']) { + return true; + } + // Check permissions against the aclGroup provided (array of userId/roles) + if (aclGroup.some(acl => { + return perms[acl] === true; + })) { + return true; + } + return false; + } + + // Validates an operation passes class-level-permissions set in the schema + validatePermission(className, aclGroup, operation) { + + if (this.testBaseCLP(className, aclGroup, operation)) { + return Promise.resolve(); + } + + if (!this.perms[className] || !this.perms[className][operation]) { + return true; + } + const classPerms = this.perms[className]; + const perms = classPerms[operation]; + + // If only for authenticated users + // make sure we have an aclGroup + if (perms['requiresAuthentication']) { + // If aclGroup has * (public) + if (!aclGroup || aclGroup.length == 0) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Permission denied, user needs to be authenticated.'); + } else if (aclGroup.indexOf('*') > -1 && aclGroup.length == 1) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Permission denied, user needs to be authenticated.'); + } + // requiresAuthentication passed, just move forward + // probably would be wise at some point to rename to 'authenticatedUser' + return Promise.resolve(); + } + + // No matching CLP, let's check the Pointer permissions + // And handle those later + const permissionField = ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields'; + + // Reject create when write lockdown + if (permissionField == 'writeUserFields' && operation == 'create') { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, `Permission denied for action ${operation} on class ${className}.`); + } + + // Process the readUserFields later + if (Array.isArray(classPerms[permissionField]) && classPerms[permissionField].length > 0) { + 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 + getExpectedType(className, fieldName) { + if (this.data && this.data[className]) { + const expectedType = this.data[className][fieldName]; + return expectedType === 'map' ? 'Object' : expectedType; + } + return undefined; + } + + // Checks if a given class is in the schema. + hasClass(className) { + return this.reloadData().then(() => !!this.data[className]); + } +} + +exports.default = SchemaController; // Returns a promise for a new Schema. + +const load = (dbAdapter, schemaCache, options) => { + const schema = new SchemaController(dbAdapter, schemaCache); + return schema.reloadData(options).then(() => schema); +}; + +// Builds a new schema (in schema API response format) out of an +// existing mongo schema + a schemas API put request. This response +// does not include the default fields, as it is intended to be passed +// to mongoSchemaFromFieldsAndClassName. No validation is done here, it +// is done in mongoSchemaFromFieldsAndClassName. +function buildMergedSchemaObject(existingFields, putRequest) { + const newSchema = {}; + const sysSchemaField = Object.keys(defaultColumns).indexOf(existingFields._id) === -1 ? [] : Object.keys(defaultColumns[existingFields._id]); + for (const oldField in existingFields) { + if (oldField !== '_id' && oldField !== 'ACL' && oldField !== 'updatedAt' && oldField !== 'createdAt' && oldField !== 'objectId') { + if (sysSchemaField.length > 0 && sysSchemaField.indexOf(oldField) !== -1) { + continue; + } + const fieldIsDeleted = putRequest[oldField] && putRequest[oldField].__op === 'Delete'; + if (!fieldIsDeleted) { + newSchema[oldField] = existingFields[oldField]; + } + } + } + for (const newField in putRequest) { + if (newField !== 'objectId' && putRequest[newField].__op !== 'Delete') { + if (sysSchemaField.length > 0 && sysSchemaField.indexOf(newField) !== -1) { + continue; + } + newSchema[newField] = putRequest[newField]; + } + } + return newSchema; +} + +// Given a schema promise, construct another schema promise that +// validates this field once the schema loads. +function thenValidateRequiredColumns(schemaPromise, className, object, query) { + return schemaPromise.then(schema => { + return schema.validateRequiredColumns(className, object, query); + }); +} + +// Gets the type from a REST API formatted object, where 'type' is +// extended past javascript types to include the rest of the Parse +// type system. +// The output should be a valid schema value. +// TODO: ensure that this is compatible with the format used in Open DB +function getType(obj) { + const 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; + } +} + +// This gets the type for non-JSON types like pointers and files, but +// also gets the appropriate type for $ operators. +// Returns null if the type is unknown. +function getObjectType(obj) { + if (obj instanceof Array) { + return 'Array'; + } + if (obj.__type) { + switch (obj.__type) { + case 'Pointer': + if (obj.className) { + return { + type: 'Pointer', + targetClass: obj.className + }; + } + break; + case 'Relation': + if (obj.className) { + return { + type: 'Relation', + targetClass: obj.className + }; + } + 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 'Bytes'; + } + break; + case 'Polygon': + if (obj.coordinates) { + return 'Polygon'; + } + 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; + } + } + return 'Object'; +} + +exports.load = load; +exports.classNameIsValid = classNameIsValid; +exports.fieldNameIsValid = fieldNameIsValid; +exports.invalidClassNameMessage = invalidClassNameMessage; +exports.buildMergedSchemaObject = buildMergedSchemaObject; +exports.systemClasses = systemClasses; +exports.defaultColumns = defaultColumns; +exports.convertSchemaToAdapterSchema = convertSchemaToAdapterSchema; +exports.VolatileClassesSchemas = VolatileClassesSchemas; \ No newline at end of file diff --git a/lib/Controllers/UserController.js b/lib/Controllers/UserController.js new file mode 100644 index 0000000000..898ebaa770 --- /dev/null +++ b/lib/Controllers/UserController.js @@ -0,0 +1,259 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.UserController = undefined; + +var _cryptoUtils = require('../cryptoUtils'); + +var _triggers = require('../triggers'); + +var _AdaptableController = require('./AdaptableController'); + +var _AdaptableController2 = _interopRequireDefault(_AdaptableController); + +var _MailAdapter = require('../Adapters/Email/MailAdapter'); + +var _MailAdapter2 = _interopRequireDefault(_MailAdapter); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var RestQuery = require('../RestQuery'); +var Auth = require('../Auth'); + +class UserController extends _AdaptableController2.default { + + constructor(adapter, appId, options = {}) { + super(adapter, appId, options); + } + + validateAdapter(adapter) { + // Allow no adapter + if (!adapter && !this.shouldVerifyEmails) { + return; + } + super.validateAdapter(adapter); + } + + expectedAdapterType() { + return _MailAdapter2.default; + } + + get shouldVerifyEmails() { + return this.options.verifyUserEmails; + } + + setEmailVerifyToken(user) { + if (this.shouldVerifyEmails) { + user._email_verify_token = (0, _cryptoUtils.randomString)(25); + user.emailVerified = false; + + if (this.config.emailVerifyTokenValidityDuration) { + user._email_verify_token_expires_at = _node2.default._encode(this.config.generateEmailVerifyTokenExpiresAt()); + } + } + } + + verifyEmail(username, token) { + if (!this.shouldVerifyEmails) { + // Trying to verify email when not enabled + // TODO: Better error here. + throw undefined; + } + + const query = { username: username, _email_verify_token: token }; + const updateFields = { emailVerified: true, _email_verify_token: { __op: 'Delete' } }; + + // if the email verify token needs to be validated then + // add additional query params and additional fields that need to be updated + if (this.config.emailVerifyTokenValidityDuration) { + query.emailVerified = false; + query._email_verify_token_expires_at = { $gt: _node2.default._encode(new Date()) }; + + updateFields._email_verify_token_expires_at = { __op: 'Delete' }; + } + const masterAuth = Auth.master(this.config); + var checkIfAlreadyVerified = new RestQuery(this.config, Auth.master(this.config), '_User', { username: username, emailVerified: true }); + return checkIfAlreadyVerified.execute().then(result => { + if (result.results.length) { + return Promise.resolve(result.results.length[0]); + } + return _rest2.default.update(this.config, masterAuth, '_User', query, updateFields); + }); + } + + checkResetTokenValidity(username, token) { + return this.config.database.find('_User', { + username: username, + _perishable_token: token + }, { limit: 1 }).then(results => { + if (results.length != 1) { + throw undefined; + } + + if (this.config.passwordPolicy && this.config.passwordPolicy.resetTokenValidityDuration) { + let expiresDate = results[0]._perishable_token_expires_at; + if (expiresDate && expiresDate.__type == 'Date') { + expiresDate = new Date(expiresDate.iso); + } + if (expiresDate < new Date()) throw 'The password reset link has expired'; + } + + return results[0]; + }); + } + + getUserIfNeeded(user) { + if (user.username && user.email) { + return Promise.resolve(user); + } + var where = {}; + if (user.username) { + where.username = user.username; + } + if (user.email) { + where.email = user.email; + } + + var query = new RestQuery(this.config, Auth.master(this.config), '_User', where); + return query.execute().then(function (result) { + if (result.results.length != 1) { + throw undefined; + } + return result.results[0]; + }); + } + + sendVerificationEmail(user) { + if (!this.shouldVerifyEmails) { + return; + } + const token = encodeURIComponent(user._email_verify_token); + // We may need to fetch the user in case of update email + this.getUserIfNeeded(user).then(user => { + const username = encodeURIComponent(user.username); + + const link = buildEmailLink(this.config.verifyEmailURL, username, token, this.config); + const options = { + appName: this.config.appName, + link: link, + user: (0, _triggers.inflate)('_User', user) + }; + if (this.adapter.sendVerificationEmail) { + this.adapter.sendVerificationEmail(options); + } else { + this.adapter.sendMail(this.defaultVerificationEmail(options)); + } + }); + } + + resendVerificationEmail(username) { + return this.getUserIfNeeded({ username: username }).then(aUser => { + if (!aUser || aUser.emailVerified) { + throw undefined; + } + this.setEmailVerifyToken(aUser); + return this.config.database.update('_User', { username }, aUser).then(() => { + this.sendVerificationEmail(aUser); + }); + }); + } + + setPasswordResetToken(email) { + const token = { _perishable_token: (0, _cryptoUtils.randomString)(25) }; + + if (this.config.passwordPolicy && this.config.passwordPolicy.resetTokenValidityDuration) { + token._perishable_token_expires_at = _node2.default._encode(this.config.generatePasswordResetTokenExpiresAt()); + } + + return this.config.database.update('_User', { $or: [{ email }, { username: email, email: { $exists: false } }] }, token, {}, true); + } + + sendPasswordResetEmail(email) { + if (!this.adapter) { + throw "Trying to send a reset password but no adapter is set"; + // TODO: No adapter? + } + + return this.setPasswordResetToken(email).then(user => { + const token = encodeURIComponent(user._perishable_token); + const username = encodeURIComponent(user.username); + + const link = buildEmailLink(this.config.requestResetPasswordURL, username, token, this.config); + const options = { + appName: this.config.appName, + link: link, + user: (0, _triggers.inflate)('_User', user) + }; + + if (this.adapter.sendPasswordResetEmail) { + this.adapter.sendPasswordResetEmail(options); + } else { + this.adapter.sendMail(this.defaultResetPasswordEmail(options)); + } + + return Promise.resolve(user); + }); + } + + updatePassword(username, token, password) { + return this.checkResetTokenValidity(username, token).then(user => updateUserPassword(user.objectId, password, this.config)) + // clear reset password token + .then(() => this.config.database.update('_User', { username }, { + _perishable_token: { __op: 'Delete' }, + _perishable_token_expires_at: { __op: 'Delete' } + })).catch(error => { + if (error.message) { + // in case of Parse.Error, fail with the error message only + return Promise.reject(error.message); + } else { + return Promise.reject(error); + } + }); + } + + defaultVerificationEmail({ link, user, appName }) { + const 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; + const to = user.get("email"); + const subject = 'Please verify your e-mail for ' + appName; + return { text, to, subject }; + } + + defaultResetPasswordEmail({ link, user, appName }) { + const text = "Hi,\n\n" + "You requested to reset your password for " + appName + (user.get('username') ? " (your username is '" + user.get('username') + "')" : "") + ".\n\n" + "" + "Click here to reset it:\n" + link; + const to = user.get("email") || user.get('username'); + const subject = 'Password Reset for ' + appName; + return { text, to, subject }; + } +} + +exports.UserController = UserController; // Mark this private + +function updateUserPassword(userId, password, config) { + return _rest2.default.update(config, Auth.master(config), '_User', { objectId: userId }, { + password: password + }); +} + +function buildEmailLink(destination, username, token, config) { + const usernameAndToken = `token=${token}&username=${username}`; + + if (config.parseFrameURL) { + const destinationWithoutHost = destination.replace(config.publicServerURL, ''); + + return `${config.parseFrameURL}?link=${encodeURIComponent(destinationWithoutHost)}&${usernameAndToken}`; + } else { + return `${destination}?${usernameAndToken}`; + } +} + +exports.default = UserController; \ No newline at end of file diff --git a/lib/Controllers/index.js b/lib/Controllers/index.js new file mode 100644 index 0000000000..2d2a6dfb88 --- /dev/null +++ b/lib/Controllers/index.js @@ -0,0 +1,282 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getControllers = getControllers; +exports.getLoggerController = getLoggerController; +exports.getFilesController = getFilesController; +exports.getUserController = getUserController; +exports.getCacheController = getCacheController; +exports.getAnalyticsController = getAnalyticsController; +exports.getLiveQueryController = getLiveQueryController; +exports.getDatabaseController = getDatabaseController; +exports.getHooksController = getHooksController; +exports.getPushController = getPushController; +exports.getAuthDataManager = getAuthDataManager; +exports.getDatabaseAdapter = getDatabaseAdapter; + +var _Auth = require('../Adapters/Auth'); + +var _Auth2 = _interopRequireDefault(_Auth); + +var _Options = require('../Options'); + +var _AdapterLoader = require('../Adapters/AdapterLoader'); + +var _defaults = require('../defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +var _url = require('url'); + +var _url2 = _interopRequireDefault(_url); + +var _LoggerController = require('./LoggerController'); + +var _FilesController = require('./FilesController'); + +var _HooksController = require('./HooksController'); + +var _UserController = require('./UserController'); + +var _CacheController = require('./CacheController'); + +var _LiveQueryController = require('./LiveQueryController'); + +var _AnalyticsController = require('./AnalyticsController'); + +var _PushController = require('./PushController'); + +var _PushQueue = require('../Push/PushQueue'); + +var _PushWorker = require('../Push/PushWorker'); + +var _DatabaseController = require('./DatabaseController'); + +var _DatabaseController2 = _interopRequireDefault(_DatabaseController); + +var _SchemaCache = require('./SchemaCache'); + +var _SchemaCache2 = _interopRequireDefault(_SchemaCache); + +var _GridStoreAdapter = require('../Adapters/Files/GridStoreAdapter'); + +var _WinstonLoggerAdapter = require('../Adapters/Logger/WinstonLoggerAdapter'); + +var _InMemoryCacheAdapter = require('../Adapters/Cache/InMemoryCacheAdapter'); + +var _AnalyticsAdapter = require('../Adapters/Analytics/AnalyticsAdapter'); + +var _MongoStorageAdapter = require('../Adapters/Storage/Mongo/MongoStorageAdapter'); + +var _MongoStorageAdapter2 = _interopRequireDefault(_MongoStorageAdapter); + +var _PostgresStorageAdapter = require('../Adapters/Storage/Postgres/PostgresStorageAdapter'); + +var _PostgresStorageAdapter2 = _interopRequireDefault(_PostgresStorageAdapter); + +var _pushAdapter = require('@parse/push-adapter'); + +var _pushAdapter2 = _interopRequireDefault(_pushAdapter); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function getControllers(options) { + const loggerController = getLoggerController(options); + const filesController = getFilesController(options); + const userController = getUserController(options); + const { + pushController, + hasPushScheduledSupport, + hasPushSupport, + pushControllerQueue, + pushWorker + } = getPushController(options); + const cacheController = getCacheController(options); + const analyticsController = getAnalyticsController(options); + const liveQueryController = getLiveQueryController(options); + const databaseController = getDatabaseController(options, cacheController); + const hooksController = getHooksController(options, databaseController); + const authDataManager = getAuthDataManager(options); + return { + loggerController, + filesController, + userController, + pushController, + hasPushScheduledSupport, + hasPushSupport, + pushWorker, + pushControllerQueue, + analyticsController, + cacheController, + liveQueryController, + databaseController, + hooksController, + authDataManager + }; +} + +// Adapters + +// Controllers +function getLoggerController(options) { + const { + appId, + jsonLogs, + logsFolder, + verbose, + logLevel, + silent, + loggerAdapter + } = options; + const loggerOptions = { jsonLogs, logsFolder, verbose, logLevel, silent }; + const loggerControllerAdapter = (0, _AdapterLoader.loadAdapter)(loggerAdapter, _WinstonLoggerAdapter.WinstonLoggerAdapter, loggerOptions); + return new _LoggerController.LoggerController(loggerControllerAdapter, appId, loggerOptions); +} + +function getFilesController(options) { + const { + appId, + databaseURI, + filesAdapter, + databaseAdapter + } = options; + if (!filesAdapter && databaseAdapter) { + throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.'; + } + const filesControllerAdapter = (0, _AdapterLoader.loadAdapter)(filesAdapter, () => { + return new _GridStoreAdapter.GridStoreAdapter(databaseURI); + }); + return new _FilesController.FilesController(filesControllerAdapter, appId); +} + +function getUserController(options) { + const { + appId, + emailAdapter, + verifyUserEmails + } = options; + const emailControllerAdapter = (0, _AdapterLoader.loadAdapter)(emailAdapter); + return new _UserController.UserController(emailControllerAdapter, appId, { verifyUserEmails }); +} + +function getCacheController(options) { + const { + appId, + cacheAdapter, + cacheTTL, + cacheMaxSize + } = options; + const cacheControllerAdapter = (0, _AdapterLoader.loadAdapter)(cacheAdapter, _InMemoryCacheAdapter.InMemoryCacheAdapter, { appId: appId, ttl: cacheTTL, maxSize: cacheMaxSize }); + return new _CacheController.CacheController(cacheControllerAdapter, appId); +} + +function getAnalyticsController(options) { + const { + analyticsAdapter + } = options; + const analyticsControllerAdapter = (0, _AdapterLoader.loadAdapter)(analyticsAdapter, _AnalyticsAdapter.AnalyticsAdapter); + return new _AnalyticsController.AnalyticsController(analyticsControllerAdapter); +} + +function getLiveQueryController(options) { + return new _LiveQueryController.LiveQueryController(options.liveQuery); +} + +function getDatabaseController(options, cacheController) { + const { + databaseURI, + databaseOptions, + collectionPrefix, + schemaCacheTTL, + enableSingleSchemaCache + } = options; + let { + databaseAdapter + } = options; + if ((databaseOptions || databaseURI && databaseURI !== _defaults2.default.databaseURI || collectionPrefix !== _defaults2.default.collectionPrefix) && databaseAdapter) { + throw 'You cannot specify both a databaseAdapter and a databaseURI/databaseOptions/collectionPrefix.'; + } else if (!databaseAdapter) { + databaseAdapter = getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions); + } else { + databaseAdapter = (0, _AdapterLoader.loadAdapter)(databaseAdapter); + } + return new _DatabaseController2.default(databaseAdapter, new _SchemaCache2.default(cacheController, schemaCacheTTL, enableSingleSchemaCache)); +} + +function getHooksController(options, databaseController) { + const { + appId, + webhookKey + } = options; + return new _HooksController.HooksController(appId, databaseController, webhookKey); +} + +function getPushController(options) { + const { + scheduledPush, + push + } = options; + + const pushOptions = Object.assign({}, push); + const pushQueueOptions = pushOptions.queueOptions || {}; + if (pushOptions.queueOptions) { + delete pushOptions.queueOptions; + } + + // Pass the push options too as it works with the default + const pushAdapter = (0, _AdapterLoader.loadAdapter)(pushOptions && pushOptions.adapter, _pushAdapter2.default, pushOptions); + // We pass the options and the base class for the adatper, + // Note that passing an instance would work too + const pushController = new _PushController.PushController(); + const hasPushSupport = !!(pushAdapter && push); + const hasPushScheduledSupport = hasPushSupport && scheduledPush === true; + + const { + disablePushWorker + } = pushQueueOptions; + + const pushControllerQueue = new _PushQueue.PushQueue(pushQueueOptions); + let pushWorker; + if (!disablePushWorker) { + pushWorker = new _PushWorker.PushWorker(pushAdapter, pushQueueOptions); + } + return { + pushController, + hasPushSupport, + hasPushScheduledSupport, + pushControllerQueue, + pushWorker + }; +} + +function getAuthDataManager(options) { + const { + auth, + enableAnonymousUsers + } = options; + return (0, _Auth2.default)(auth, enableAnonymousUsers); +} + +function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) { + let protocol; + try { + const parsedURI = _url2.default.parse(databaseURI); + protocol = parsedURI.protocol ? parsedURI.protocol.toLowerCase() : null; + } catch (e) {/* */} + switch (protocol) { + case 'postgres:': + return new _PostgresStorageAdapter2.default({ + uri: databaseURI, + collectionPrefix, + databaseOptions + }); + default: + return new _MongoStorageAdapter2.default({ + uri: databaseURI, + collectionPrefix, + mongoOptions: databaseOptions + }); + } +} \ No newline at end of file diff --git a/lib/LiveQuery/Client.js b/lib/LiveQuery/Client.js new file mode 100644 index 0000000000..dc97207772 --- /dev/null +++ b/lib/LiveQuery/Client.js @@ -0,0 +1,97 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Client = undefined; + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const dafaultFields = ['className', 'objectId', 'updatedAt', 'createdAt', 'ACL']; + +class Client { + + constructor(id, parseWebSocket, hasMasterKey) { + this.id = id; + this.parseWebSocket = parseWebSocket; + this.hasMasterKey = hasMasterKey; + this.roles = []; + this.subscriptionInfos = new Map(); + this.pushConnect = this._pushEvent('connected'); + this.pushSubscribe = this._pushEvent('subscribed'); + this.pushUnsubscribe = this._pushEvent('unsubscribed'); + this.pushCreate = this._pushEvent('create'); + this.pushEnter = this._pushEvent('enter'); + this.pushUpdate = this._pushEvent('update'); + this.pushDelete = this._pushEvent('delete'); + this.pushLeave = this._pushEvent('leave'); + } + + static pushResponse(parseWebSocket, message) { + _logger2.default.verbose('Push Response : %j', message); + parseWebSocket.send(message); + } + + static pushError(parseWebSocket, code, error, reconnect = true) { + Client.pushResponse(parseWebSocket, JSON.stringify({ + 'op': 'error', + 'error': error, + 'code': code, + 'reconnect': reconnect + })); + } + + addSubscriptionInfo(requestId, subscriptionInfo) { + this.subscriptionInfos.set(requestId, subscriptionInfo); + } + + getSubscriptionInfo(requestId) { + return this.subscriptionInfos.get(requestId); + } + + deleteSubscriptionInfo(requestId) { + return this.subscriptionInfos.delete(requestId); + } + + _pushEvent(type) { + return function (subscriptionId, parseObjectJSON) { + const response = { + 'op': type, + 'clientId': this.id + }; + if (typeof subscriptionId !== 'undefined') { + response['requestId'] = subscriptionId; + } + if (typeof parseObjectJSON !== 'undefined') { + let fields; + if (this.subscriptionInfos.has(subscriptionId)) { + fields = this.subscriptionInfos.get(subscriptionId).fields; + } + response['object'] = this._toJSONWithFields(parseObjectJSON, fields); + } + Client.pushResponse(this.parseWebSocket, JSON.stringify(response)); + }; + } + + _toJSONWithFields(parseObjectJSON, fields) { + if (!fields) { + return parseObjectJSON; + } + const limitedParseObject = {}; + for (const field of dafaultFields) { + limitedParseObject[field] = parseObjectJSON[field]; + } + for (const field of fields) { + if (field in parseObjectJSON) { + limitedParseObject[field] = parseObjectJSON[field]; + } + } + return limitedParseObject; + } +} + +exports.Client = Client; \ No newline at end of file diff --git a/lib/LiveQuery/Id.js b/lib/LiveQuery/Id.js new file mode 100644 index 0000000000..72fb66d6a6 --- /dev/null +++ b/lib/LiveQuery/Id.js @@ -0,0 +1,22 @@ +'use strict'; + +class Id { + + constructor(className, objectId) { + this.className = className; + this.objectId = objectId; + } + toString() { + return this.className + ':' + this.objectId; + } + + static fromString(str) { + var split = str.split(':'); + if (split.length !== 2) { + throw new TypeError('Cannot create Id object from this string'); + } + return new Id(split[0], split[1]); + } +} + +module.exports = Id; \ No newline at end of file diff --git a/lib/LiveQuery/ParseCloudCodePublisher.js b/lib/LiveQuery/ParseCloudCodePublisher.js new file mode 100644 index 0000000000..cbc1c691bf --- /dev/null +++ b/lib/LiveQuery/ParseCloudCodePublisher.js @@ -0,0 +1,50 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ParseCloudCodePublisher = undefined; + +var _ParsePubSub = require('./ParsePubSub'); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class ParseCloudCodePublisher { + + // config object of the publisher, right now it only contains the redisURL, + // but we may extend it later. + constructor(config = {}) { + this.parsePublisher = _ParsePubSub.ParsePubSub.createPublisher(config); + } + + onCloudCodeAfterSave(request) { + this._onCloudCodeMessage(_node2.default.applicationId + 'afterSave', request); + } + + onCloudCodeAfterDelete(request) { + this._onCloudCodeMessage(_node2.default.applicationId + 'afterDelete', request); + } + + // Request is the request object from cloud code functions. request.object is a ParseObject. + _onCloudCodeMessage(type, request) { + _logger2.default.verbose('Raw request from cloud code current : %j | original : %j', request.object, request.original); + // We need the full JSON which includes className + const message = { + currentParseObject: request.object._toFullJSON() + }; + if (request.original) { + message.originalParseObject = request.original._toFullJSON(); + } + this.parsePublisher.publish(type, JSON.stringify(message)); + } +} + +exports.ParseCloudCodePublisher = ParseCloudCodePublisher; \ No newline at end of file diff --git a/lib/LiveQuery/ParseLiveQueryServer.js b/lib/LiveQuery/ParseLiveQueryServer.js new file mode 100644 index 0000000000..30188195ee --- /dev/null +++ b/lib/LiveQuery/ParseLiveQueryServer.js @@ -0,0 +1,580 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ParseLiveQueryServer = undefined; + +var _tv = require('tv4'); + +var _tv2 = _interopRequireDefault(_tv); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _Subscription = require('./Subscription'); + +var _Client = require('./Client'); + +var _ParseWebSocketServer = require('./ParseWebSocketServer'); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +var _RequestSchema = require('./RequestSchema'); + +var _RequestSchema2 = _interopRequireDefault(_RequestSchema); + +var _QueryTools = require('./QueryTools'); + +var _ParsePubSub = require('./ParsePubSub'); + +var _SessionTokenCache = require('./SessionTokenCache'); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _uuid = require('uuid'); + +var _uuid2 = _interopRequireDefault(_uuid); + +var _triggers = require('../triggers'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class ParseLiveQueryServer { + // className -> (queryHash -> subscription) + constructor(server, config) { + this.server = server; + this.clients = new Map(); + this.subscriptions = new Map(); + + config = config || {}; + + // Store keys, convert obj to map + const keyPairs = config.keyPairs || {}; + this.keyPairs = new Map(); + for (const key of Object.keys(keyPairs)) { + this.keyPairs.set(key, keyPairs[key]); + } + _logger2.default.verbose('Support key pairs', this.keyPairs); + + // Initialize Parse + _node2.default.Object.disableSingleInstance(); + + const serverURL = config.serverURL || _node2.default.serverURL; + _node2.default.serverURL = serverURL; + const appId = config.appId || _node2.default.applicationId; + const javascriptKey = _node2.default.javaScriptKey; + const masterKey = config.masterKey || _node2.default.masterKey; + _node2.default.initialize(appId, javascriptKey, masterKey); + + // Initialize websocket server + this.parseWebSocketServer = new _ParseWebSocketServer.ParseWebSocketServer(server, parseWebsocket => this._onConnect(parseWebsocket), config.websocketTimeout); + + // Initialize subscriber + this.subscriber = _ParsePubSub.ParsePubSub.createSubscriber(config); + this.subscriber.subscribe(_node2.default.applicationId + 'afterSave'); + this.subscriber.subscribe(_node2.default.applicationId + 'afterDelete'); + // Register message handler for subscriber. When publisher get messages, it will publish message + // to the subscribers and the handler will be called. + this.subscriber.on('message', (channel, messageStr) => { + _logger2.default.verbose('Subscribe messsage %j', messageStr); + let message; + try { + message = JSON.parse(messageStr); + } catch (e) { + _logger2.default.error('unable to parse message', messageStr, e); + return; + } + this._inflateParseObject(message); + if (channel === _node2.default.applicationId + 'afterSave') { + this._onAfterSave(message); + } else if (channel === _node2.default.applicationId + 'afterDelete') { + this._onAfterDelete(message); + } else { + _logger2.default.error('Get message %s from unknown channel %j', message, channel); + } + }); + + // Initialize sessionToken cache + this.sessionTokenCache = new _SessionTokenCache.SessionTokenCache(config.cacheTimeout); + } + + // Message is the JSON object from publisher. Message.currentParseObject is the ParseObject JSON after changes. + // Message.originalParseObject is the original ParseObject JSON. + + // The subscriber we use to get object update from publisher + _inflateParseObject(message) { + // Inflate merged object + const currentParseObject = message.currentParseObject; + let className = currentParseObject.className; + let parseObject = new _node2.default.Object(className); + parseObject._finishFetch(currentParseObject); + message.currentParseObject = parseObject; + // Inflate original object + const originalParseObject = message.originalParseObject; + if (originalParseObject) { + className = originalParseObject.className; + parseObject = new _node2.default.Object(className); + parseObject._finishFetch(originalParseObject); + message.originalParseObject = parseObject; + } + } + + // Message is the JSON object from publisher after inflated. Message.currentParseObject is the ParseObject after changes. + // Message.originalParseObject is the original ParseObject. + _onAfterDelete(message) { + _logger2.default.verbose(_node2.default.applicationId + 'afterDelete is triggered'); + + const deletedParseObject = message.currentParseObject.toJSON(); + const className = deletedParseObject.className; + _logger2.default.verbose('ClassName: %j | ObjectId: %s', className, deletedParseObject.id); + _logger2.default.verbose('Current client number : %d', this.clients.size); + + const classSubscriptions = this.subscriptions.get(className); + if (typeof classSubscriptions === 'undefined') { + _logger2.default.debug('Can not find subscriptions under this class ' + className); + return; + } + for (const subscription of classSubscriptions.values()) { + const isSubscriptionMatched = this._matchesSubscription(deletedParseObject, subscription); + if (!isSubscriptionMatched) { + continue; + } + for (const [clientId, requestIds] of _lodash2.default.entries(subscription.clientRequestIds)) { + const client = this.clients.get(clientId); + if (typeof client === 'undefined') { + continue; + } + for (const requestId of requestIds) { + const acl = message.currentParseObject.getACL(); + // Check ACL + this._matchesACL(acl, client, requestId).then(isMatched => { + if (!isMatched) { + return null; + } + client.pushDelete(requestId, deletedParseObject); + }, error => { + _logger2.default.error('Matching ACL error : ', error); + }); + } + } + } + } + + // Message is the JSON object from publisher after inflated. Message.currentParseObject is the ParseObject after changes. + // Message.originalParseObject is the original ParseObject. + _onAfterSave(message) { + _logger2.default.verbose(_node2.default.applicationId + 'afterSave is triggered'); + + let originalParseObject = null; + if (message.originalParseObject) { + originalParseObject = message.originalParseObject.toJSON(); + } + const currentParseObject = message.currentParseObject.toJSON(); + const className = currentParseObject.className; + _logger2.default.verbose('ClassName: %s | ObjectId: %s', className, currentParseObject.id); + _logger2.default.verbose('Current client number : %d', this.clients.size); + + const classSubscriptions = this.subscriptions.get(className); + if (typeof classSubscriptions === 'undefined') { + _logger2.default.debug('Can not find subscriptions under this class ' + className); + return; + } + for (const subscription of classSubscriptions.values()) { + const isOriginalSubscriptionMatched = this._matchesSubscription(originalParseObject, subscription); + const isCurrentSubscriptionMatched = this._matchesSubscription(currentParseObject, subscription); + for (const [clientId, requestIds] of _lodash2.default.entries(subscription.clientRequestIds)) { + const client = this.clients.get(clientId); + if (typeof client === 'undefined') { + continue; + } + for (const requestId of requestIds) { + // Set orignal ParseObject ACL checking promise, if the object does not match + // subscription, we do not need to check ACL + let originalACLCheckingPromise; + if (!isOriginalSubscriptionMatched) { + originalACLCheckingPromise = _node2.default.Promise.as(false); + } else { + let originalACL; + if (message.originalParseObject) { + originalACL = message.originalParseObject.getACL(); + } + originalACLCheckingPromise = this._matchesACL(originalACL, client, requestId); + } + // Set current ParseObject ACL checking promise, if the object does not match + // subscription, we do not need to check ACL + let currentACLCheckingPromise; + if (!isCurrentSubscriptionMatched) { + currentACLCheckingPromise = _node2.default.Promise.as(false); + } else { + const currentACL = message.currentParseObject.getACL(); + currentACLCheckingPromise = this._matchesACL(currentACL, client, requestId); + } + + _node2.default.Promise.when(originalACLCheckingPromise, currentACLCheckingPromise).then((isOriginalMatched, isCurrentMatched) => { + _logger2.default.verbose('Original %j | Current %j | Match: %s, %s, %s, %s | Query: %s', originalParseObject, currentParseObject, isOriginalSubscriptionMatched, isCurrentSubscriptionMatched, isOriginalMatched, isCurrentMatched, subscription.hash); + + // Decide event type + let type; + if (isOriginalMatched && isCurrentMatched) { + type = 'Update'; + } else if (isOriginalMatched && !isCurrentMatched) { + type = 'Leave'; + } else if (!isOriginalMatched && isCurrentMatched) { + if (originalParseObject) { + type = 'Enter'; + } else { + type = 'Create'; + } + } else { + return null; + } + const functionName = 'push' + type; + client[functionName](requestId, currentParseObject); + }, error => { + _logger2.default.error('Matching ACL error : ', error); + }); + } + } + } + } + + _onConnect(parseWebsocket) { + parseWebsocket.on('message', request => { + if (typeof request === 'string') { + try { + request = JSON.parse(request); + } catch (e) { + _logger2.default.error('unable to parse request', request, e); + return; + } + } + _logger2.default.verbose('Request: %j', request); + + // Check whether this request is a valid request, return error directly if not + if (!_tv2.default.validate(request, _RequestSchema2.default['general']) || !_tv2.default.validate(request, _RequestSchema2.default[request.op])) { + _Client.Client.pushError(parseWebsocket, 1, _tv2.default.error.message); + _logger2.default.error('Connect message error %s', _tv2.default.error.message); + return; + } + + switch (request.op) { + case 'connect': + this._handleConnect(parseWebsocket, request); + break; + case 'subscribe': + this._handleSubscribe(parseWebsocket, request); + break; + case 'update': + this._handleUpdateSubscription(parseWebsocket, request); + break; + case 'unsubscribe': + this._handleUnsubscribe(parseWebsocket, request); + break; + default: + _Client.Client.pushError(parseWebsocket, 3, 'Get unknown operation'); + _logger2.default.error('Get unknown operation', request.op); + } + }); + + parseWebsocket.on('disconnect', () => { + _logger2.default.info(`Client disconnect: ${parseWebsocket.clientId}`); + const clientId = parseWebsocket.clientId; + if (!this.clients.has(clientId)) { + (0, _triggers.runLiveQueryEventHandlers)({ + event: 'ws_disconnect_error', + clients: this.clients.size, + subscriptions: this.subscriptions.size, + error: `Unable to find client ${clientId}` + }); + _logger2.default.error(`Can not find client ${clientId} on disconnect`); + return; + } + + // Delete client + const client = this.clients.get(clientId); + this.clients.delete(clientId); + + // Delete client from subscriptions + for (const [requestId, subscriptionInfo] of _lodash2.default.entries(client.subscriptionInfos)) { + const subscription = subscriptionInfo.subscription; + subscription.deleteClientSubscription(clientId, requestId); + + // If there is no client which is subscribing this subscription, remove it from subscriptions + const classSubscriptions = this.subscriptions.get(subscription.className); + if (!subscription.hasSubscribingClient()) { + classSubscriptions.delete(subscription.hash); + } + // If there is no subscriptions under this class, remove it from subscriptions + if (classSubscriptions.size === 0) { + this.subscriptions.delete(subscription.className); + } + } + + _logger2.default.verbose('Current clients %d', this.clients.size); + _logger2.default.verbose('Current subscriptions %d', this.subscriptions.size); + (0, _triggers.runLiveQueryEventHandlers)({ + event: 'ws_disconnect', + clients: this.clients.size, + subscriptions: this.subscriptions.size + }); + }); + + (0, _triggers.runLiveQueryEventHandlers)({ + event: 'ws_connect', + clients: this.clients.size, + subscriptions: this.subscriptions.size + }); + } + + _matchesSubscription(parseObject, subscription) { + // Object is undefined or null, not match + if (!parseObject) { + return false; + } + return (0, _QueryTools.matchesQuery)(parseObject, subscription.query); + } + + _matchesACL(acl, client, requestId) { + // Return true directly if ACL isn't present, ACL is public read, or client has master key + if (!acl || acl.getPublicReadAccess() || client.hasMasterKey) { + return _node2.default.Promise.as(true); + } + // Check subscription sessionToken matches ACL first + const subscriptionInfo = client.getSubscriptionInfo(requestId); + if (typeof subscriptionInfo === 'undefined') { + return _node2.default.Promise.as(false); + } + + const subscriptionSessionToken = subscriptionInfo.sessionToken; + return this.sessionTokenCache.getUserId(subscriptionSessionToken).then(userId => { + return acl.getReadAccess(userId); + }).then(isSubscriptionSessionTokenMatched => { + if (isSubscriptionSessionTokenMatched) { + return _node2.default.Promise.as(true); + } + + // Check if the user has any roles that match the ACL + return new _node2.default.Promise((resolve, reject) => { + + // Resolve false right away if the acl doesn't have any roles + const acl_has_roles = Object.keys(acl.permissionsById).some(key => key.startsWith("role:")); + if (!acl_has_roles) { + return resolve(false); + } + + this.sessionTokenCache.getUserId(subscriptionSessionToken).then(userId => { + + // Pass along a null if there is no user id + if (!userId) { + return _node2.default.Promise.as(null); + } + + // Prepare a user object to query for roles + // To eliminate a query for the user, create one locally with the id + var user = new _node2.default.User(); + user.id = userId; + return user; + }).then(user => { + + // Pass along an empty array (of roles) if no user + if (!user) { + return _node2.default.Promise.as([]); + } + + // Then get the user's roles + var rolesQuery = new _node2.default.Query(_node2.default.Role); + rolesQuery.equalTo("users", user); + return rolesQuery.find({ useMasterKey: true }); + }).then(roles => { + + // Finally, see if any of the user's roles allow them read access + for (const role of roles) { + if (acl.getRoleReadAccess(role)) { + return resolve(true); + } + } + resolve(false); + }).catch(error => { + reject(error); + }); + }); + }).then(isRoleMatched => { + + if (isRoleMatched) { + return _node2.default.Promise.as(true); + } + + // Check client sessionToken matches ACL + const clientSessionToken = client.sessionToken; + return this.sessionTokenCache.getUserId(clientSessionToken).then(userId => { + return acl.getReadAccess(userId); + }); + }).then(isMatched => { + return _node2.default.Promise.as(isMatched); + }, () => { + return _node2.default.Promise.as(false); + }); + } + + _handleConnect(parseWebsocket, request) { + if (!this._validateKeys(request, this.keyPairs)) { + _Client.Client.pushError(parseWebsocket, 4, 'Key in request is not valid'); + _logger2.default.error('Key in request is not valid'); + return; + } + const hasMasterKey = this._hasMasterKey(request, this.keyPairs); + const clientId = (0, _uuid2.default)(); + const client = new _Client.Client(clientId, parseWebsocket, hasMasterKey); + parseWebsocket.clientId = clientId; + this.clients.set(parseWebsocket.clientId, client); + _logger2.default.info(`Create new client: ${parseWebsocket.clientId}`); + client.pushConnect(); + (0, _triggers.runLiveQueryEventHandlers)({ + event: 'connect', + clients: this.clients.size, + subscriptions: this.subscriptions.size + }); + } + + _hasMasterKey(request, validKeyPairs) { + if (!validKeyPairs || validKeyPairs.size == 0 || !validKeyPairs.has("masterKey")) { + return false; + } + if (!request || !request.hasOwnProperty("masterKey")) { + return false; + } + return request.masterKey === validKeyPairs.get("masterKey"); + } + + _validateKeys(request, validKeyPairs) { + if (!validKeyPairs || validKeyPairs.size == 0) { + return true; + } + let isValid = false; + for (const [key, secret] of validKeyPairs) { + if (!request[key] || request[key] !== secret) { + continue; + } + isValid = true; + break; + } + return isValid; + } + + _handleSubscribe(parseWebsocket, request) { + // If we can not find this client, return error to client + if (!parseWebsocket.hasOwnProperty('clientId')) { + _Client.Client.pushError(parseWebsocket, 2, 'Can not find this client, make sure you connect to server before subscribing'); + _logger2.default.error('Can not find this client, make sure you connect to server before subscribing'); + return; + } + const client = this.clients.get(parseWebsocket.clientId); + + // Get subscription from subscriptions, create one if necessary + const subscriptionHash = (0, _QueryTools.queryHash)(request.query); + // Add className to subscriptions if necessary + const className = request.query.className; + if (!this.subscriptions.has(className)) { + this.subscriptions.set(className, new Map()); + } + const classSubscriptions = this.subscriptions.get(className); + let subscription; + if (classSubscriptions.has(subscriptionHash)) { + subscription = classSubscriptions.get(subscriptionHash); + } else { + subscription = new _Subscription.Subscription(className, request.query.where, subscriptionHash); + classSubscriptions.set(subscriptionHash, subscription); + } + + // Add subscriptionInfo to client + const subscriptionInfo = { + subscription: subscription + }; + // Add selected fields and sessionToken for this subscription if necessary + if (request.query.fields) { + subscriptionInfo.fields = request.query.fields; + } + if (request.sessionToken) { + subscriptionInfo.sessionToken = request.sessionToken; + } + client.addSubscriptionInfo(request.requestId, subscriptionInfo); + + // Add clientId to subscription + subscription.addClientSubscription(parseWebsocket.clientId, request.requestId); + + client.pushSubscribe(request.requestId); + + _logger2.default.verbose(`Create client ${parseWebsocket.clientId} new subscription: ${request.requestId}`); + _logger2.default.verbose('Current client number: %d', this.clients.size); + (0, _triggers.runLiveQueryEventHandlers)({ + event: 'subscribe', + clients: this.clients.size, + subscriptions: this.subscriptions.size + }); + } + + _handleUpdateSubscription(parseWebsocket, request) { + this._handleUnsubscribe(parseWebsocket, request, false); + this._handleSubscribe(parseWebsocket, request); + } + + _handleUnsubscribe(parseWebsocket, request, notifyClient = true) { + // If we can not find this client, return error to client + if (!parseWebsocket.hasOwnProperty('clientId')) { + _Client.Client.pushError(parseWebsocket, 2, 'Can not find this client, make sure you connect to server before unsubscribing'); + _logger2.default.error('Can not find this client, make sure you connect to server before unsubscribing'); + return; + } + const requestId = request.requestId; + const client = this.clients.get(parseWebsocket.clientId); + if (typeof client === 'undefined') { + _Client.Client.pushError(parseWebsocket, 2, 'Cannot find client with clientId ' + parseWebsocket.clientId + '. Make sure you connect to live query server before unsubscribing.'); + _logger2.default.error('Can not find this client ' + parseWebsocket.clientId); + return; + } + + const subscriptionInfo = client.getSubscriptionInfo(requestId); + if (typeof subscriptionInfo === 'undefined') { + _Client.Client.pushError(parseWebsocket, 2, 'Cannot find subscription with clientId ' + parseWebsocket.clientId + ' subscriptionId ' + requestId + '. Make sure you subscribe to live query server before unsubscribing.'); + _logger2.default.error('Can not find subscription with clientId ' + parseWebsocket.clientId + ' subscriptionId ' + requestId); + return; + } + + // Remove subscription from client + client.deleteSubscriptionInfo(requestId); + // Remove client from subscription + const subscription = subscriptionInfo.subscription; + const className = subscription.className; + subscription.deleteClientSubscription(parseWebsocket.clientId, requestId); + // If there is no client which is subscribing this subscription, remove it from subscriptions + const classSubscriptions = this.subscriptions.get(className); + if (!subscription.hasSubscribingClient()) { + classSubscriptions.delete(subscription.hash); + } + // If there is no subscriptions under this class, remove it from subscriptions + if (classSubscriptions.size === 0) { + this.subscriptions.delete(className); + } + (0, _triggers.runLiveQueryEventHandlers)({ + event: 'unsubscribe', + clients: this.clients.size, + subscriptions: this.subscriptions.size + }); + + if (!notifyClient) { + return; + } + + client.pushUnsubscribe(request.requestId); + + _logger2.default.verbose(`Delete client: ${parseWebsocket.clientId} | subscription: ${request.requestId}`); + } +} + +exports.ParseLiveQueryServer = ParseLiveQueryServer; \ No newline at end of file diff --git a/lib/LiveQuery/ParsePubSub.js b/lib/LiveQuery/ParsePubSub.js new file mode 100644 index 0000000000..6686db2607 --- /dev/null +++ b/lib/LiveQuery/ParsePubSub.js @@ -0,0 +1,45 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ParsePubSub = undefined; + +var _AdapterLoader = require('../Adapters/AdapterLoader'); + +var _EventEmitterPubSub = require('../Adapters/PubSub/EventEmitterPubSub'); + +var _RedisPubSub = require('../Adapters/PubSub/RedisPubSub'); + +const ParsePubSub = {}; + +function useRedis(config) { + const redisURL = config.redisURL; + return typeof redisURL !== 'undefined' && redisURL !== ''; +} + +ParsePubSub.createPublisher = function (config) { + if (useRedis(config)) { + return _RedisPubSub.RedisPubSub.createPublisher(config); + } else { + const adapter = (0, _AdapterLoader.loadAdapter)(config.pubSubAdapter, _EventEmitterPubSub.EventEmitterPubSub, config); + if (typeof adapter.createPublisher !== 'function') { + throw 'pubSubAdapter should have createPublisher()'; + } + return adapter.createPublisher(config); + } +}; + +ParsePubSub.createSubscriber = function (config) { + if (useRedis(config)) { + return _RedisPubSub.RedisPubSub.createSubscriber(config); + } else { + const adapter = (0, _AdapterLoader.loadAdapter)(config.pubSubAdapter, _EventEmitterPubSub.EventEmitterPubSub, config); + if (typeof adapter.createSubscriber !== 'function') { + throw 'pubSubAdapter should have createSubscriber()'; + } + return adapter.createSubscriber(config); + } +}; + +exports.ParsePubSub = ParsePubSub; \ No newline at end of file diff --git a/lib/LiveQuery/ParseWebSocketServer.js b/lib/LiveQuery/ParseWebSocketServer.js new file mode 100644 index 0000000000..f59723886c --- /dev/null +++ b/lib/LiveQuery/ParseWebSocketServer.js @@ -0,0 +1,62 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ParseWebSocket = exports.ParseWebSocketServer = undefined; + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const typeMap = new Map([['disconnect', 'close']]); +const getWS = function () { + try { + return require('uws'); + } catch (e) { + return require('ws'); + } +}; + +class ParseWebSocketServer { + + constructor(server, onConnect, websocketTimeout = 10 * 1000) { + const WebSocketServer = getWS().Server; + const wss = new WebSocketServer({ server: server }); + wss.on('listening', () => { + _logger2.default.info('Parse LiveQuery Server starts running'); + }); + wss.on('connection', ws => { + onConnect(new ParseWebSocket(ws)); + // Send ping to client periodically + const pingIntervalId = setInterval(() => { + if (ws.readyState == ws.OPEN) { + ws.ping(); + } else { + clearInterval(pingIntervalId); + } + }, websocketTimeout); + }); + this.server = wss; + } +} + +exports.ParseWebSocketServer = ParseWebSocketServer; +class ParseWebSocket { + + constructor(ws) { + this.ws = ws; + } + + on(type, callback) { + const wsType = typeMap.has(type) ? typeMap.get(type) : type; + this.ws.on(wsType, callback); + } + + send(message) { + this.ws.send(message); + } +} +exports.ParseWebSocket = ParseWebSocket; \ No newline at end of file diff --git a/lib/LiveQuery/QueryTools.js b/lib/LiveQuery/QueryTools.js new file mode 100644 index 0000000000..74d528c8f8 --- /dev/null +++ b/lib/LiveQuery/QueryTools.js @@ -0,0 +1,320 @@ +'use strict'; + +var equalObjects = require('./equalObjects'); +var Id = require('./Id'); +var Parse = require('parse/node'); + +/** + * Query Hashes are deterministic hashes for Parse Queries. + * Any two queries that have the same set of constraints will produce the same + * hash. This lets us reliably group components by the queries they depend upon, + * and quickly determine if a query has changed. + */ + +/** + * Convert $or queries into an array of where conditions + */ +function flattenOrQueries(where) { + if (!where.hasOwnProperty('$or')) { + return where; + } + var accum = []; + for (var i = 0; i < where.$or.length; i++) { + accum = accum.concat(where.$or[i]); + } + return accum; +} + +/** + * Deterministically turns an object into a string. Disregards ordering + */ +function stringify(object) { + if (typeof object !== 'object' || object === null) { + if (typeof object === 'string') { + return '"' + object.replace(/\|/g, '%|') + '"'; + } + return object + ''; + } + if (Array.isArray(object)) { + var copy = object.map(stringify); + copy.sort(); + return '[' + copy.join(',') + ']'; + } + var sections = []; + var keys = Object.keys(object); + keys.sort(); + for (var k = 0; k < keys.length; k++) { + sections.push(stringify(keys[k]) + ':' + stringify(object[keys[k]])); + } + return '{' + sections.join(',') + '}'; +} + +/** + * Generate a hash from a query, with unique fields for columns, values, order, + * skip, and limit. + */ +function queryHash(query) { + if (query instanceof Parse.Query) { + query = { + className: query.className, + where: query._where + }; + } + var where = flattenOrQueries(query.where || {}); + var columns = []; + var values = []; + var i; + if (Array.isArray(where)) { + var uniqueColumns = {}; + for (i = 0; i < where.length; i++) { + var subValues = {}; + var keys = Object.keys(where[i]); + keys.sort(); + for (var j = 0; j < keys.length; j++) { + subValues[keys[j]] = where[i][keys[j]]; + uniqueColumns[keys[j]] = true; + } + values.push(subValues); + } + columns = Object.keys(uniqueColumns); + columns.sort(); + } else { + columns = Object.keys(where); + columns.sort(); + for (i = 0; i < columns.length; i++) { + values.push(where[columns[i]]); + } + } + + var sections = [columns.join(','), stringify(values)]; + + return query.className + ':' + sections.join('|'); +} + +/** + * contains -- Determines if an object is contained in a list with special handling for Parse pointers. + */ +function contains(haystack, needle) { + if (needle && needle.__type && needle.__type === 'Pointer') { + for (const i in haystack) { + const ptr = haystack[i]; + if (typeof ptr === 'string' && ptr === needle.objectId) { + return true; + } + if (ptr.className === needle.className && ptr.objectId === needle.objectId) { + return true; + } + } + return false; + } + return haystack.indexOf(needle) > -1; +} +/** + * matchesQuery -- Determines if an object would be returned by a Parse Query + * It's a lightweight, where-clause only implementation of a full query engine. + * Since we find queries that match objects, rather than objects that match + * queries, we can avoid building a full-blown query tool. + */ +function matchesQuery(object, query) { + if (query instanceof Parse.Query) { + var className = object.id instanceof Id ? object.id.className : object.className; + if (className !== query.className) { + return false; + } + return matchesQuery(object, query._where); + } + for (var field in query) { + if (!matchesKeyConstraints(object, field, query[field])) { + return false; + } + } + return true; +} + +function equalObjectsGeneric(obj, compareTo, eqlFn) { + if (Array.isArray(obj)) { + for (var i = 0; i < obj.length; i++) { + if (eqlFn(obj[i], compareTo)) { + return true; + } + } + return false; + } + + return eqlFn(obj, compareTo); +} + +/** + * Determines whether an object matches a single key's constraints + */ +function matchesKeyConstraints(object, key, constraints) { + if (constraints === null) { + return false; + } + if (key.indexOf(".") >= 0) { + // Key references a subobject + var keyComponents = key.split("."); + var subObjectKey = keyComponents[0]; + var keyRemainder = keyComponents.slice(1).join("."); + return matchesKeyConstraints(object[subObjectKey] || {}, keyRemainder, constraints); + } + var i; + if (key === '$or') { + for (i = 0; i < constraints.length; i++) { + if (matchesQuery(object, constraints[i])) { + return true; + } + } + return false; + } + if (key === '$relatedTo') { + // Bail! We can't handle relational queries locally + return false; + } + // Equality (or Array contains) cases + if (typeof constraints !== 'object') { + if (Array.isArray(object[key])) { + return object[key].indexOf(constraints) > -1; + } + return object[key] === constraints; + } + var compareTo; + if (constraints.__type) { + if (constraints.__type === 'Pointer') { + return equalObjectsGeneric(object[key], constraints, function (obj, ptr) { + return typeof obj !== 'undefined' && ptr.className === obj.className && ptr.objectId === obj.objectId; + }); + } + + return equalObjectsGeneric(object[key], Parse._decode(key, constraints), equalObjects); + } + // More complex cases + for (var condition in constraints) { + compareTo = constraints[condition]; + if (compareTo.__type) { + compareTo = Parse._decode(key, compareTo); + } + switch (condition) { + case '$lt': + if (object[key] >= compareTo) { + return false; + } + break; + case '$lte': + if (object[key] > compareTo) { + return false; + } + break; + case '$gt': + if (object[key] <= compareTo) { + return false; + } + break; + case '$gte': + if (object[key] < compareTo) { + return false; + } + break; + case '$ne': + if (equalObjects(object[key], compareTo)) { + return false; + } + break; + case '$in': + if (!contains(compareTo, object[key])) { + return false; + } + break; + case '$nin': + if (contains(compareTo, object[key])) { + return false; + } + break; + case '$all': + for (i = 0; i < compareTo.length; i++) { + if (object[key].indexOf(compareTo[i]) < 0) { + return false; + } + } + break; + case '$exists': + { + const propertyExists = typeof object[key] !== 'undefined'; + const existenceIsRequired = constraints['$exists']; + if (typeof constraints['$exists'] !== 'boolean') { + // The SDK will never submit a non-boolean for $exists, but if someone + // tries to submit a non-boolean for $exits outside the SDKs, just ignore it. + break; + } + if (!propertyExists && existenceIsRequired || propertyExists && !existenceIsRequired) { + return false; + } + break; + } + case '$regex': + if (typeof compareTo === 'object') { + return compareTo.test(object[key]); + } + // JS doesn't support perl-style escaping + var expString = ''; + var escapeEnd = -2; + var escapeStart = compareTo.indexOf('\\Q'); + while (escapeStart > -1) { + // Add the unescaped portion + expString += compareTo.substring(escapeEnd + 2, escapeStart); + escapeEnd = compareTo.indexOf('\\E', escapeStart); + if (escapeEnd > -1) { + expString += compareTo.substring(escapeStart + 2, escapeEnd).replace(/\\\\\\\\E/g, '\\E').replace(/\W/g, '\\$&'); + } + + escapeStart = compareTo.indexOf('\\Q', escapeEnd); + } + expString += compareTo.substring(Math.max(escapeStart, escapeEnd + 2)); + var exp = new RegExp(expString, constraints.$options || ''); + if (!exp.test(object[key])) { + return false; + } + break; + case '$nearSphere': + if (!compareTo || !object[key]) { + return false; + } + var distance = compareTo.radiansTo(object[key]); + var max = constraints.$maxDistance || Infinity; + return distance <= max; + case '$within': + if (!compareTo || !object[key]) { + return false; + } + var southWest = compareTo.$box[0]; + var northEast = compareTo.$box[1]; + if (southWest.latitude > northEast.latitude || southWest.longitude > northEast.longitude) { + // Invalid box, crosses the date line + return false; + } + return object[key].latitude > southWest.latitude && object[key].latitude < northEast.latitude && object[key].longitude > southWest.longitude && object[key].longitude < northEast.longitude; + case '$options': + // Not a query type, but a way to add options to $regex. Ignore and + // avoid the default + break; + case '$maxDistance': + // Not a query type, but a way to add a cap to $nearSphere. Ignore and + // avoid the default + break; + case '$select': + return false; + case '$dontSelect': + return false; + default: + return false; + } + } + return true; +} + +var QueryTools = { + queryHash: queryHash, + matchesQuery: matchesQuery +}; + +module.exports = QueryTools; \ No newline at end of file diff --git a/lib/LiveQuery/RequestSchema.js b/lib/LiveQuery/RequestSchema.js new file mode 100644 index 0000000000..a0a7e511c7 --- /dev/null +++ b/lib/LiveQuery/RequestSchema.js @@ -0,0 +1,145 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +const general = { + 'title': 'General request schema', + 'type': 'object', + 'properties': { + 'op': { + 'type': 'string', + 'enum': ['connect', 'subscribe', 'unsubscribe', 'update'] + } + } +}; + +const connect = { + 'title': 'Connect operation schema', + 'type': 'object', + 'properties': { + 'op': 'connect', + 'applicationId': { + 'type': 'string' + }, + 'javascriptKey': { + type: 'string' + }, + 'masterKey': { + type: 'string' + }, + 'clientKey': { + type: 'string' + }, + 'windowsKey': { + type: 'string' + }, + 'restAPIKey': { + 'type': 'string' + }, + 'sessionToken': { + 'type': 'string' + } + }, + 'required': ['op', 'applicationId'], + "additionalProperties": false +}; + +const subscribe = { + 'title': 'Subscribe operation schema', + 'type': 'object', + 'properties': { + 'op': 'subscribe', + 'requestId': { + 'type': 'number' + }, + 'query': { + 'title': 'Query field schema', + 'type': 'object', + 'properties': { + 'className': { + 'type': 'string' + }, + 'where': { + 'type': 'object' + }, + 'fields': { + "type": "array", + "items": { + "type": "string" + }, + "minItems": 1, + "uniqueItems": true + } + }, + 'required': ['where', 'className'], + 'additionalProperties': false + }, + 'sessionToken': { + 'type': 'string' + } + }, + 'required': ['op', 'requestId', 'query'], + 'additionalProperties': false +}; + +const update = { + 'title': 'Update operation schema', + 'type': 'object', + 'properties': { + 'op': 'update', + 'requestId': { + 'type': 'number' + }, + 'query': { + 'title': 'Query field schema', + 'type': 'object', + 'properties': { + 'className': { + 'type': 'string' + }, + 'where': { + 'type': 'object' + }, + 'fields': { + "type": "array", + "items": { + "type": "string" + }, + "minItems": 1, + "uniqueItems": true + } + }, + 'required': ['where', 'className'], + 'additionalProperties': false + }, + 'sessionToken': { + 'type': 'string' + } + }, + 'required': ['op', 'requestId', 'query'], + 'additionalProperties': false +}; + +const unsubscribe = { + 'title': 'Unsubscribe operation schema', + 'type': 'object', + 'properties': { + 'op': 'unsubscribe', + 'requestId': { + 'type': 'number' + } + }, + 'required': ['op', 'requestId'], + "additionalProperties": false +}; + +const RequestSchema = { + 'general': general, + 'connect': connect, + 'subscribe': subscribe, + 'update': update, + 'unsubscribe': unsubscribe +}; + +exports.default = RequestSchema; \ No newline at end of file diff --git a/lib/LiveQuery/SessionTokenCache.js b/lib/LiveQuery/SessionTokenCache.js new file mode 100644 index 0000000000..82056f7439 --- /dev/null +++ b/lib/LiveQuery/SessionTokenCache.js @@ -0,0 +1,63 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.SessionTokenCache = undefined; + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _lruCache = require('lru-cache'); + +var _lruCache2 = _interopRequireDefault(_lruCache); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function userForSessionToken(sessionToken) { + var q = new _node2.default.Query("_Session"); + q.equalTo("sessionToken", sessionToken); + return q.first({ useMasterKey: true }).then(function (session) { + if (!session) { + return _node2.default.Promise.error("No session found for session token"); + } + return session.get("user"); + }); +} + +class SessionTokenCache { + + constructor(timeout = 30 * 24 * 60 * 60 * 1000, maxSize = 10000) { + this.cache = new _lruCache2.default({ + max: maxSize, + maxAge: timeout + }); + } + + getUserId(sessionToken) { + if (!sessionToken) { + return _node2.default.Promise.error('Empty sessionToken'); + } + const userId = this.cache.get(sessionToken); + if (userId) { + _logger2.default.verbose('Fetch userId %s of sessionToken %s from Cache', userId, sessionToken); + return _node2.default.Promise.as(userId); + } + return userForSessionToken(sessionToken).then(user => { + _logger2.default.verbose('Fetch userId %s of sessionToken %s from Parse', user.id, sessionToken); + const userId = user.id; + this.cache.set(sessionToken, userId); + return _node2.default.Promise.as(userId); + }, error => { + _logger2.default.error('Can not fetch userId for sessionToken %j, error %j', sessionToken, error); + return _node2.default.Promise.error(error); + }); + } +} + +exports.SessionTokenCache = SessionTokenCache; \ No newline at end of file diff --git a/lib/LiveQuery/Subscription.js b/lib/LiveQuery/Subscription.js new file mode 100644 index 0000000000..8d0019fda0 --- /dev/null +++ b/lib/LiveQuery/Subscription.js @@ -0,0 +1,55 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Subscription = undefined; + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class Subscription { + // It is query condition eg query.where + constructor(className, query, queryHash) { + this.className = className; + this.query = query; + this.hash = queryHash; + this.clientRequestIds = new Map(); + } + + addClientSubscription(clientId, requestId) { + if (!this.clientRequestIds.has(clientId)) { + this.clientRequestIds.set(clientId, []); + } + const requestIds = this.clientRequestIds.get(clientId); + requestIds.push(requestId); + } + + deleteClientSubscription(clientId, requestId) { + const requestIds = this.clientRequestIds.get(clientId); + if (typeof requestIds === 'undefined') { + _logger2.default.error('Can not find client %d to delete', clientId); + return; + } + + const index = requestIds.indexOf(requestId); + if (index < 0) { + _logger2.default.error('Can not find client %d subscription %d to delete', clientId, requestId); + return; + } + requestIds.splice(index, 1); + // Delete client reference if it has no subscription + if (requestIds.length == 0) { + this.clientRequestIds.delete(clientId); + } + } + + hasSubscribingClient() { + return this.clientRequestIds.size > 0; + } +} + +exports.Subscription = Subscription; \ No newline at end of file diff --git a/lib/LiveQuery/equalObjects.js b/lib/LiveQuery/equalObjects.js new file mode 100644 index 0000000000..bb3890a748 --- /dev/null +++ b/lib/LiveQuery/equalObjects.js @@ -0,0 +1,50 @@ +'use strict'; + +var toString = Object.prototype.toString; + +/** + * Determines whether two objects represent the same primitive, special Parse + * type, or full Parse Object. + */ +function equalObjects(a, b) { + if (typeof a !== typeof b) { + return false; + } + if (typeof a !== 'object') { + return a === b; + } + if (a === b) { + return true; + } + if (toString.call(a) === '[object Date]') { + if (toString.call(b) === '[object Date]') { + return +a === +b; + } + return false; + } + if (Array.isArray(a)) { + if (Array.isArray(b)) { + if (a.length !== b.length) { + return false; + } + for (var i = 0; i < a.length; i++) { + if (!equalObjects(a[i], b[i])) { + return false; + } + } + return true; + } + return false; + } + if (Object.keys(a).length !== Object.keys(b).length) { + return false; + } + for (var key in a) { + if (!equalObjects(a[key], b[key])) { + return false; + } + } + return true; +} + +module.exports = equalObjects; \ No newline at end of file diff --git a/lib/Options/Definitions.js b/lib/Options/Definitions.js new file mode 100644 index 0000000000..7cd842f3c3 --- /dev/null +++ b/lib/Options/Definitions.js @@ -0,0 +1,388 @@ +/* +**** GENERATED CODE **** +This code has been generated by resources/buildConfigDefinitions.js +Do not edit manually, but update Options/index.js +*/"use strict"; + +var parsers = require("./parsers"); + +module.exports.ParseServerOptions = { + "appId": { + "env": "PARSE_SERVER_APPLICATION_ID", + "help": "Your Parse Application ID", + "required": true + }, + "masterKey": { + "env": "PARSE_SERVER_MASTER_KEY", + "help": "Your Parse Master Key", + "required": true + }, + "serverURL": { + "env": "PARSE_SERVER_URL", + "help": "URL to your parse server with http:// or https://.", + "required": true + }, + "masterKeyIps": { + "env": "PARSE_SERVER_MASTER_KEY_IPS", + "help": "Restrict masterKey to be used by only these ips. defaults to [] (allow all ips)", + "action": parsers.arrayParser, + "default": [] + }, + "appName": { + "env": "PARSE_SERVER_APP_NAME", + "help": "Sets the app name" + }, + "analyticsAdapter": { + "env": "PARSE_SERVER_ANALYTICS_ADAPTER", + "help": "Adapter module for the analytics", + "action": parsers.moduleOrObjectParser + }, + "filesAdapter": { + "env": "PARSE_SERVER_FILES_ADAPTER", + "help": "Adapter module for the files sub-system", + "action": parsers.moduleOrObjectParser + }, + "push": { + "env": "PARSE_SERVER_PUSH", + "help": "Configuration for push, as stringified JSON. See http://docs.parseplatform.org/parse-server/guide/#push-notifications", + "action": parsers.objectParser + }, + "scheduledPush": { + "env": "PARSE_SERVER_SCHEDULED_PUSH", + "help": "Configuration for push scheduling. Defaults to false.", + "action": parsers.booleanParser, + "default": false + }, + "loggerAdapter": { + "env": "PARSE_SERVER_LOGGER_ADAPTER", + "help": "Adapter module for the logging sub-system", + "action": parsers.moduleOrObjectParser + }, + "jsonLogs": { + "env": "JSON_LOGS", + "help": "Log as structured JSON objects", + "action": parsers.booleanParser + }, + "logsFolder": { + "env": "PARSE_SERVER_LOGS_FOLDER", + "help": "Folder for the logs (defaults to './logs'); set to null to disable file based logging", + "default": "./logs" + }, + "verbose": { + "env": "VERBOSE", + "help": "Set the logging to verbose", + "action": parsers.booleanParser + }, + "logLevel": { + "env": "PARSE_SERVER_LOG_LEVEL", + "help": "Sets the level for logs" + }, + "silent": { + "env": "SILENT", + "help": "Disables console output", + "action": parsers.booleanParser + }, + "databaseURI": { + "env": "PARSE_SERVER_DATABASE_URI", + "help": "The full URI to your mongodb database", + "required": true, + "default": "mongodb://localhost:27017/parse" + }, + "databaseOptions": { + "env": "PARSE_SERVER_DATABASE_OPTIONS", + "help": "Options to pass to the mongodb client", + "action": parsers.objectParser + }, + "databaseAdapter": { + "env": "PARSE_SERVER_DATABASE_ADAPTER", + "help": "Adapter module for the database", + "action": parsers.moduleOrObjectParser + }, + "cloud": { + "env": "PARSE_SERVER_CLOUD", + "help": "Full path to your cloud code main.js" + }, + "collectionPrefix": { + "env": "PARSE_SERVER_COLLECTION_PREFIX", + "help": "A collection prefix for the classes", + "default": "" + }, + "clientKey": { + "env": "PARSE_SERVER_CLIENT_KEY", + "help": "Key for iOS, MacOS, tvOS clients" + }, + "javascriptKey": { + "env": "PARSE_SERVER_JAVASCRIPT_KEY", + "help": "Key for the Javascript SDK" + }, + "dotNetKey": { + "env": "PARSE_SERVER_DOT_NET_KEY", + "help": "Key for Unity and .Net SDK" + }, + "restAPIKey": { + "env": "PARSE_SERVER_REST_API_KEY", + "help": "Key for REST calls" + }, + "readOnlyMasterKey": { + "env": "PARSE_SERVER_READ_ONLY_MASTER_KEY", + "help": "Read-only key, which has the same capabilities as MasterKey without writes" + }, + "webhookKey": { + "env": "PARSE_SERVER_WEBHOOK_KEY", + "help": "Key sent with outgoing webhook calls" + }, + "fileKey": { + "env": "PARSE_SERVER_FILE_KEY", + "help": "Key for your files" + }, + "userSensitiveFields": { + "env": "PARSE_SERVER_USER_SENSITIVE_FIELDS", + "help": "Personally identifiable information fields in the user table the should be removed for non-authorized users.", + "action": parsers.arrayParser, + "default": ["email"] + }, + "enableAnonymousUsers": { + "env": "PARSE_SERVER_ENABLE_ANON_USERS", + "help": "Enable (or disable) anon users, defaults to true", + "action": parsers.booleanParser, + "default": true + }, + "allowClientClassCreation": { + "env": "PARSE_SERVER_ALLOW_CLIENT_CLASS_CREATION", + "help": "Enable (or disable) client class creation, defaults to true", + "action": parsers.booleanParser, + "default": true + }, + "auth": { + "env": "PARSE_SERVER_AUTH_PROVIDERS", + "help": "Configuration for your authentication providers, as stringified JSON. See http://docs.parseplatform.org/parse-server/guide/#oauth-and-3rd-party-authentication", + "action": parsers.objectParser + }, + "maxUploadSize": { + "env": "PARSE_SERVER_MAX_UPLOAD_SIZE", + "help": "Max file size for uploads. defaults to 20mb", + "default": "20mb" + }, + "verifyUserEmails": { + "env": "PARSE_SERVER_VERIFY_USER_EMAILS", + "help": "Enable (or disable) user email validation, defaults to false", + "action": parsers.booleanParser, + "default": false + }, + "preventLoginWithUnverifiedEmail": { + "env": "PARSE_SERVER_PREVENT_LOGIN_WITH_UNVERIFIED_EMAIL", + "help": "Prevent user from login if email is not verified and PARSE_SERVER_VERIFY_USER_EMAILS is true, defaults to false", + "action": parsers.booleanParser, + "default": false + }, + "emailVerifyTokenValidityDuration": { + "env": "PARSE_SERVER_EMAIL_VERIFY_TOKEN_VALIDITY_DURATION", + "help": "Email verification token validity duration", + "action": parsers.numberParser("emailVerifyTokenValidityDuration") + }, + "accountLockout": { + "env": "PARSE_SERVER_ACCOUNT_LOCKOUT", + "help": "account lockout policy for failed login attempts", + "action": parsers.objectParser + }, + "passwordPolicy": { + "env": "PARSE_SERVER_PASSWORD_POLICY", + "help": "Password policy for enforcing password related rules", + "action": parsers.objectParser + }, + "cacheAdapter": { + "env": "PARSE_SERVER_CACHE_ADAPTER", + "help": "Adapter module for the cache", + "action": parsers.moduleOrObjectParser + }, + "emailAdapter": { + "env": "PARSE_SERVER_EMAIL_ADAPTER", + "help": "Adapter module for the email sending", + "action": parsers.moduleOrObjectParser + }, + "publicServerURL": { + "env": "PARSE_PUBLIC_SERVER_URL", + "help": "Public URL to your parse server with http:// or https://." + }, + "customPages": { + "env": "PARSE_SERVER_CUSTOM_PAGES", + "help": "custom pages for password validation and reset", + "action": parsers.objectParser, + "default": {} + }, + "liveQuery": { + "env": "PARSE_SERVER_LIVE_QUERY", + "help": "parse-server's LiveQuery configuration object", + "action": parsers.objectParser + }, + "sessionLength": { + "env": "PARSE_SERVER_SESSION_LENGTH", + "help": "Session duration, in seconds, defaults to 1 year", + "action": parsers.numberParser("sessionLength"), + "default": 31536000 + }, + "maxLimit": { + "env": "PARSE_SERVER_MAX_LIMIT", + "help": "Max value for limit option on queries, defaults to unlimited", + "action": parsers.numberParser("maxLimit") + }, + "expireInactiveSessions": { + "env": "PARSE_SERVER_EXPIRE_INACTIVE_SESSIONS", + "help": "Sets wether we should expire the inactive sessions, defaults to true", + "action": parsers.booleanParser, + "default": true + }, + "revokeSessionOnPasswordReset": { + "env": "PARSE_SERVER_REVOKE_SESSION_ON_PASSWORD_RESET", + "help": "When a user changes their password, either through the reset password email or while logged in, all sessions are revoked if this is true. Set to false if you don't want to revoke sessions.", + "action": parsers.booleanParser, + "default": true + }, + "schemaCacheTTL": { + "env": "PARSE_SERVER_SCHEMA_CACHE_TTL", + "help": "The TTL for caching the schema for optimizing read/write operations. You should put a long TTL when your DB is in production. default to 5000; set 0 to disable.", + "action": parsers.numberParser("schemaCacheTTL"), + "default": 5000 + }, + "cacheTTL": { + "env": "PARSE_SERVER_CACHE_TTL", + "help": "Sets the TTL for the in memory cache (in ms), defaults to 5000 (5 seconds)", + "action": parsers.numberParser("cacheTTL"), + "default": 5000 + }, + "cacheMaxSize": { + "env": "PARSE_SERVER_CACHE_MAX_SIZE", + "help": "Sets the maximum size for the in memory cache, defaults to 10000", + "action": parsers.numberParser("cacheMaxSize"), + "default": 10000 + }, + "enableSingleSchemaCache": { + "env": "PARSE_SERVER_ENABLE_SINGLE_SCHEMA_CACHE", + "help": "Use a single schema cache shared across requests. Reduces number of queries made to _SCHEMA. Defaults to false, i.e. unique schema cache per request.", + "action": parsers.booleanParser, + "default": false + }, + "objectIdSize": { + "env": "PARSE_SERVER_OBJECT_ID_SIZE", + "help": "Sets the number of characters in generated object id's, default 10", + "action": parsers.numberParser("objectIdSize"), + "default": 10 + }, + "port": { + "env": "PORT", + "help": "The port to run the ParseServer. defaults to 1337.", + "action": parsers.numberParser("port"), + "default": 1337 + }, + "host": { + "env": "PARSE_SERVER_HOST", + "help": "The host to serve ParseServer on. defaults to 0.0.0.0", + "default": "0.0.0.0" + }, + "mountPath": { + "env": "PARSE_SERVER_MOUNT_PATH", + "help": "Mount path for the server, defaults to /parse", + "default": "/parse" + }, + "cluster": { + "env": "PARSE_SERVER_CLUSTER", + "help": "Run with cluster, optionally set the number of processes default to os.cpus().length", + "action": parsers.numberOrBooleanParser + }, + "middleware": { + "env": "PARSE_SERVER_MIDDLEWARE", + "help": "middleware for express server, can be string or function" + }, + "startLiveQueryServer": { + "env": "PARSE_SERVER_START_LIVE_QUERY_SERVER", + "help": "Starts the liveQuery server", + "action": parsers.booleanParser + }, + "liveQueryServerOptions": { + "env": "PARSE_SERVER_LIVE_QUERY_SERVER_OPTIONS", + "help": "Live query server configuration options (will start the liveQuery server)", + "action": parsers.objectParser + } +}; +module.exports.CustomPagesOptions = { + "invalidLink": { + "env": "PARSE_SERVER_CUSTOM_PAGES_INVALID_LINK", + "help": "invalid link page path" + }, + "verifyEmailSuccess": { + "env": "PARSE_SERVER_CUSTOM_PAGES_VERIFY_EMAIL_SUCCESS", + "help": "verify email success page path" + }, + "choosePassword": { + "env": "PARSE_SERVER_CUSTOM_PAGES_CHOOSE_PASSWORD", + "help": "choose password page path" + }, + "passwordResetSuccess": { + "env": "PARSE_SERVER_CUSTOM_PAGES_PASSWORD_RESET_SUCCESS", + "help": "password reset success page path" + } +}; +module.exports.LiveQueryOptions = { + "classNames": { + "env": "PARSE_SERVER_LIVEQUERY_CLASSNAMES", + "help": "parse-server's LiveQuery classNames", + "action": parsers.arrayParser + }, + "redisURL": { + "env": "PARSE_SERVER_LIVEQUERY_REDIS_URL", + "help": "parse-server's LiveQuery redisURL" + }, + "pubSubAdapter": { + "env": "PARSE_SERVER_LIVEQUERY_PUB_SUB_ADAPTER", + "help": "LiveQuery pubsub adapter", + "action": parsers.moduleOrObjectParser + } +}; +module.exports.LiveQueryServerOptions = { + "appId": { + "env": "PARSE_LIVE_QUERY_SERVER_APP_ID", + "help": "This string should match the appId in use by your Parse Server. If you deploy the LiveQuery server alongside Parse Server, the LiveQuery server will try to use the same appId." + }, + "masterKey": { + "env": "PARSE_LIVE_QUERY_SERVER_MASTER_KEY", + "help": "This string should match the masterKey in use by your Parse Server. If you deploy the LiveQuery server alongside Parse Server, the LiveQuery server will try to use the same masterKey." + }, + "serverURL": { + "env": "PARSE_LIVE_QUERY_SERVER_SERVER_URL", + "help": "This string should match the serverURL in use by your Parse Server. If you deploy the LiveQuery server alongside Parse Server, the LiveQuery server will try to use the same serverURL." + }, + "keyPairs": { + "env": "PARSE_LIVE_QUERY_SERVER_KEY_PAIRS", + "help": "A JSON object that serves as a whitelist of keys. It is used for validating clients when they try to connect to the LiveQuery server. Check the following Security section and our protocol specification for details.", + "action": parsers.objectParser + }, + "websocketTimeout": { + "env": "PARSE_LIVE_QUERY_SERVER_WEBSOCKET_TIMEOUT", + "help": "Number of milliseconds between ping/pong frames. The WebSocket server sends ping/pong frames to the clients to keep the WebSocket alive. This value defines the interval of the ping/pong frame from the server to clients. Defaults to 10 * 1000 ms (10 s).", + "action": parsers.numberParser("websocketTimeout") + }, + "cacheTimeout": { + "env": "PARSE_LIVE_QUERY_SERVER_CACHE_TIMEOUT", + "help": "Number in milliseconds. When clients provide the sessionToken to the LiveQuery server, the LiveQuery server will try to fetch its ParseUser's objectId from parse server and store it in the cache. The value defines the duration of the cache. Check the following Security section and our protocol specification for details. Defaults to 30 * 24 * 60 * 60 * 1000 ms (~30 days).", + "action": parsers.numberParser("cacheTimeout") + }, + "logLevel": { + "env": "PARSE_LIVE_QUERY_SERVER_LOG_LEVEL", + "help": "This string defines the log level of the LiveQuery server. We support VERBOSE, INFO, ERROR, NONE. Defaults to INFO." + }, + "port": { + "env": "PARSE_LIVE_QUERY_SERVER_PORT", + "help": "The port to run the ParseServer. defaults to 1337.", + "action": parsers.numberParser("port"), + "default": 1337 + }, + "redisURL": { + "env": "PARSE_LIVE_QUERY_SERVER_REDIS_URL", + "help": "parse-server's LiveQuery redisURL" + }, + "pubSubAdapter": { + "env": "PARSE_LIVE_QUERY_SERVER_PUB_SUB_ADAPTER", + "help": "LiveQuery pubsub adapter", + "action": parsers.moduleOrObjectParser + } +}; \ No newline at end of file diff --git a/lib/Options/index.js b/lib/Options/index.js new file mode 100644 index 0000000000..9a390c31f7 --- /dev/null +++ b/lib/Options/index.js @@ -0,0 +1 @@ +"use strict"; \ No newline at end of file diff --git a/lib/Options/parsers.js b/lib/Options/parsers.js new file mode 100644 index 0000000000..4b93c680e9 --- /dev/null +++ b/lib/Options/parsers.js @@ -0,0 +1,77 @@ +'use strict'; + +function numberParser(key) { + return function (opt) { + const intOpt = parseInt(opt); + if (!Number.isInteger(intOpt)) { + throw new Error(`Key ${key} has invalid value ${opt}`); + } + return intOpt; + }; +} + +function numberOrBoolParser(key) { + return function (opt) { + if (typeof opt === 'boolean') { + return opt; + } + if (opt === 'true') { + return true; + } + if (opt === 'false') { + return false; + } + return numberParser(key)(opt); + }; +} + +function objectParser(opt) { + if (typeof opt == 'object') { + return opt; + } + return JSON.parse(opt); +} + +function arrayParser(opt) { + if (Array.isArray(opt)) { + return opt; + } else if (typeof opt === 'string') { + return opt.split(','); + } else { + throw new Error(`${opt} should be a comma separated string or an array`); + } +} + +function moduleOrObjectParser(opt) { + if (typeof opt == 'object') { + return opt; + } + try { + return JSON.parse(opt); + } catch (e) {/* */} + return opt; +} + +function booleanParser(opt) { + if (opt == true || opt == 'true' || opt == '1') { + return true; + } + return false; +} + +function nullParser(opt) { + if (opt == 'null') { + return null; + } + return opt; +} + +module.exports = { + numberParser, + numberOrBoolParser, + nullParser, + booleanParser, + moduleOrObjectParser, + arrayParser, + objectParser +}; \ No newline at end of file diff --git a/lib/ParseMessageQueue.js b/lib/ParseMessageQueue.js new file mode 100644 index 0000000000..617324204d --- /dev/null +++ b/lib/ParseMessageQueue.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ParseMessageQueue = undefined; + +var _AdapterLoader = require('./Adapters/AdapterLoader'); + +var _EventEmitterMQ = require('./Adapters/MessageQueue/EventEmitterMQ'); + +const ParseMessageQueue = {}; + +ParseMessageQueue.createPublisher = function (config) { + const adapter = (0, _AdapterLoader.loadAdapter)(config.messageQueueAdapter, _EventEmitterMQ.EventEmitterMQ, config); + if (typeof adapter.createPublisher !== 'function') { + throw 'pubSubAdapter should have createPublisher()'; + } + return adapter.createPublisher(config); +}; + +ParseMessageQueue.createSubscriber = function (config) { + const adapter = (0, _AdapterLoader.loadAdapter)(config.messageQueueAdapter, _EventEmitterMQ.EventEmitterMQ, config); + if (typeof adapter.createSubscriber !== 'function') { + throw 'messageQueueAdapter should have createSubscriber()'; + } + return adapter.createSubscriber(config); +}; + +exports.ParseMessageQueue = ParseMessageQueue; \ No newline at end of file diff --git a/lib/ParseServer.js b/lib/ParseServer.js new file mode 100644 index 0000000000..218a37f29c --- /dev/null +++ b/lib/ParseServer.js @@ -0,0 +1,375 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _Options = require('./Options'); + +var _defaults = require('./defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +var _logger = require('./logger'); + +var logging = _interopRequireWildcard(_logger); + +var _Config = require('./Config'); + +var _Config2 = _interopRequireDefault(_Config); + +var _PromiseRouter = require('./PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _requiredParameter = require('./requiredParameter'); + +var _requiredParameter2 = _interopRequireDefault(_requiredParameter); + +var _AnalyticsRouter = require('./Routers/AnalyticsRouter'); + +var _ClassesRouter = require('./Routers/ClassesRouter'); + +var _FeaturesRouter = require('./Routers/FeaturesRouter'); + +var _FilesRouter = require('./Routers/FilesRouter'); + +var _FunctionsRouter = require('./Routers/FunctionsRouter'); + +var _GlobalConfigRouter = require('./Routers/GlobalConfigRouter'); + +var _HooksRouter = require('./Routers/HooksRouter'); + +var _IAPValidationRouter = require('./Routers/IAPValidationRouter'); + +var _InstallationsRouter = require('./Routers/InstallationsRouter'); + +var _LogsRouter = require('./Routers/LogsRouter'); + +var _ParseLiveQueryServer = require('./LiveQuery/ParseLiveQueryServer'); + +var _PublicAPIRouter = require('./Routers/PublicAPIRouter'); + +var _PushRouter = require('./Routers/PushRouter'); + +var _CloudCodeRouter = require('./Routers/CloudCodeRouter'); + +var _RolesRouter = require('./Routers/RolesRouter'); + +var _SchemasRouter = require('./Routers/SchemasRouter'); + +var _SessionsRouter = require('./Routers/SessionsRouter'); + +var _UsersRouter = require('./Routers/UsersRouter'); + +var _PurgeRouter = require('./Routers/PurgeRouter'); + +var _AudiencesRouter = require('./Routers/AudiencesRouter'); + +var _AggregateRouter = require('./Routers/AggregateRouter'); + +var _ImportRouter = require('./Routers/ImportRouter'); + +var _ExportRouter = require('./Routers/ExportRouter'); + +var _ParseServerRESTController = require('./ParseServerRESTController'); + +var _Controllers = require('./Controllers'); + +var controllers = _interopRequireWildcard(_Controllers); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// ParseServer - open-source compatible API Server for Parse apps + +var batch = require('./batch'), + bodyParser = require('body-parser'), + express = require('express'), + middlewares = require('./middlewares'), + Parse = require('parse/node').Parse, + path = require('path'); + +// Mutate the Parse object to add the Cloud Code handlers +addParseCloud(); + +// ParseServer works like a constructor of an express app. +// The args that we understand are: +// "analyticsAdapter": an adapter class for analytics +// "filesAdapter": a class like GridStoreAdapter providing create, get, +// and delete +// "loggerAdapter": a class like WinstonLoggerAdapter providing info, error, +// and query +// "jsonLogs": log as structured JSON objects +// "databaseURI": a uri like mongodb://localhost:27017/dbname to tell us +// what database this Parse API connects to. +// "cloud": relative location to cloud code to require, or a function +// that is given an instance of Parse as a parameter. Use this instance of Parse +// to register your cloud code hooks and functions. +// "appId": the application id to host +// "masterKey": the master key for requests to this app +// "collectionPrefix": optional prefix for database collection names +// "fileKey": optional key from Parse dashboard for supporting older files +// hosted by Parse +// "clientKey": optional key from Parse dashboard +// "dotNetKey": optional key from Parse dashboard +// "restAPIKey": optional key from Parse dashboard +// "webhookKey": optional key from Parse dashboard +// "javascriptKey": optional key from Parse dashboard +// "push": optional key from configure push +// "sessionLength": optional length in seconds for how long Sessions should be valid for +// "maxLimit": optional upper bound for what can be specified for the 'limit' parameter on queries + +class ParseServer { + + constructor(options) { + injectDefaults(options); + const { + appId = (0, _requiredParameter2.default)('You must provide an appId!'), + masterKey = (0, _requiredParameter2.default)('You must provide a masterKey!'), + cloud, + javascriptKey, + serverURL = (0, _requiredParameter2.default)('You must provide a serverURL!'), + __indexBuildCompletionCallbackForTests = () => {} + } = options; + // Initialize the node client SDK automatically + Parse.initialize(appId, javascriptKey || 'unused', masterKey); + Parse.serverURL = serverURL; + + const allControllers = controllers.getControllers(options); + + const { + loggerController, + databaseController, + hooksController + } = allControllers; + this.config = _Config2.default.put(Object.assign({}, options, allControllers)); + + logging.setLogger(loggerController); + const dbInitPromise = databaseController.performInitialization(); + hooksController.load(); + + // Note: Tests will start to fail if any validation happens after this is called. + if (process.env.TESTING) { + __indexBuildCompletionCallbackForTests(dbInitPromise); + } + + if (cloud) { + addParseCloud(); + if (typeof cloud === 'function') { + cloud(Parse); + } else if (typeof cloud === 'string') { + require(path.resolve(process.cwd(), cloud)); + } else { + throw "argument 'cloud' must either be a string or a function"; + } + } + } + + get app() { + if (!this._app) { + this._app = ParseServer.app(this.config); + } + return this._app; + } + + handleShutdown() { + const { adapter } = this.config.databaseController; + if (adapter && typeof adapter.handleShutdown === 'function') { + adapter.handleShutdown(); + } + } + + static app({ maxUploadSize = '20mb', appId }) { + // This app serves the Parse API directly. + // It's the equivalent of https://api.parse.com/1 in the hosted Parse API. + var api = express(); + //api.use("/apps", express.static(__dirname + "/public")); + // File handling needs to be before default middlewares are applied + api.use('/', middlewares.allowCrossDomain, new _FilesRouter.FilesRouter().expressRouter({ + maxUploadSize: maxUploadSize + })); + + api.use('/health', function (req, res) { + res.json({ + status: 'ok' + }); + }); + + api.use('/', bodyParser.urlencoded({ extended: false }), new _PublicAPIRouter.PublicAPIRouter().expressRouter()); + + api.use('/', middlewares.allowCrossDomain, new _ImportRouter.ImportRouter().expressRouter()); + api.use(bodyParser.json({ 'type': '*/*', limit: maxUploadSize })); + api.use(middlewares.allowCrossDomain); + api.use(middlewares.allowMethodOverride); + api.use(middlewares.handleParseHeaders); + + const appRouter = ParseServer.promiseRouter({ appId }); + api.use(appRouter.expressRouter()); + + api.use(middlewares.handleParseErrors); + + // run the following when not testing + if (!process.env.TESTING) { + //This causes tests to spew some useless warnings, so disable in test + /* istanbul ignore next */ + process.on('uncaughtException', err => { + if (err.code === "EADDRINUSE") { + // user-friendly message for this common error + process.stderr.write(`Unable to listen on port ${err.port}. The port is already in use.`); + process.exit(0); + } else { + throw err; + } + }); + // verify the server url after a 'mount' event is received + /* istanbul ignore next */ + api.on('mount', function () { + ParseServer.verifyServerUrl(); + }); + } + if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1') { + Parse.CoreManager.setRESTController((0, _ParseServerRESTController.ParseServerRESTController)(appId, appRouter)); + } + return api; + } + + static promiseRouter({ appId }) { + const routers = [new _ClassesRouter.ClassesRouter(), new _UsersRouter.UsersRouter(), new _SessionsRouter.SessionsRouter(), new _RolesRouter.RolesRouter(), new _AnalyticsRouter.AnalyticsRouter(), new _InstallationsRouter.InstallationsRouter(), new _FunctionsRouter.FunctionsRouter(), new _SchemasRouter.SchemasRouter(), new _PushRouter.PushRouter(), new _LogsRouter.LogsRouter(), new _IAPValidationRouter.IAPValidationRouter(), new _FeaturesRouter.FeaturesRouter(), new _GlobalConfigRouter.GlobalConfigRouter(), new _PurgeRouter.PurgeRouter(), new _ExportRouter.ExportRouter(), new _HooksRouter.HooksRouter(), new _CloudCodeRouter.CloudCodeRouter(), new _AudiencesRouter.AudiencesRouter(), new _AggregateRouter.AggregateRouter()]; + + const routes = routers.reduce((memo, router) => { + return memo.concat(router.routes); + }, []); + + const appRouter = new _PromiseRouter2.default(routes, appId); + + batch.mountOnto(appRouter); + return appRouter; + } + + start(options, callback) { + const app = express(); + if (options.middleware) { + let middleware; + if (typeof options.middleware == 'string') { + middleware = require(path.resolve(process.cwd(), options.middleware)); + } else { + middleware = options.middleware; // use as-is let express fail + } + app.use(middleware); + } + + app.use(options.mountPath, this.app); + const server = app.listen(options.port, options.host, callback); + this.server = server; + + if (options.startLiveQueryServer || options.liveQueryServerOptions) { + this.liveQueryServer = ParseServer.createLiveQueryServer(server, options.liveQueryServerOptions); + } + /* istanbul ignore next */ + if (!process.env.TESTING) { + configureListeners(this); + } + this.expressApp = app; + return this; + } + + static start(options, callback) { + const parseServer = new ParseServer(options); + return parseServer.start(options, callback); + } + + static createLiveQueryServer(httpServer, config) { + if (!httpServer || config && config.port) { + var app = express(); + httpServer = require('http').createServer(app); + httpServer.listen(config.port); + } + return new _ParseLiveQueryServer.ParseLiveQueryServer(httpServer, config); + } + + static verifyServerUrl(callback) { + // perform a health check on the serverURL value + if (Parse.serverURL) { + const request = require('request'); + request(Parse.serverURL.replace(/\/$/, "") + "/health", function (error, response, body) { + let json; + try { + json = JSON.parse(body); + } catch (e) { + json = null; + } + if (error || response.statusCode !== 200 || !json || json && json.status !== 'ok') { + /* eslint-disable no-console */ + console.warn(`\nWARNING, Unable to connect to '${Parse.serverURL}'.` + ` Cloud code and push notifications may be unavailable!\n`); + /* eslint-enable no-console */ + if (callback) { + callback(false); + } + } else { + if (callback) { + callback(true); + } + } + }); + } + } +} + +function addParseCloud() { + const ParseCloud = require("./cloud-code/Parse.Cloud"); + Object.assign(Parse.Cloud, ParseCloud); + global.Parse = Parse; +} + +function injectDefaults(options) { + Object.keys(_defaults2.default).forEach(key => { + if (!options.hasOwnProperty(key)) { + options[key] = _defaults2.default[key]; + } + }); + + if (!options.hasOwnProperty('serverURL')) { + options.serverURL = `http://localhost:${options.port}${options.mountPath}`; + } + + options.userSensitiveFields = Array.from(new Set(options.userSensitiveFields.concat(_defaults2.default.userSensitiveFields, options.userSensitiveFields))); + + options.masterKeyIps = Array.from(new Set(options.masterKeyIps.concat(_defaults2.default.masterKeyIps, options.masterKeyIps))); +} + +// Those can't be tested as it requires a subprocess +/* istanbul ignore next */ +function configureListeners(parseServer) { + const server = parseServer.server; + const sockets = {}; + /* Currently, express doesn't shut down immediately after receiving SIGINT/SIGTERM if it has client connections that haven't timed out. (This is a known issue with node - https://github.com/nodejs/node/issues/2642) + This function, along with `destroyAliveConnections()`, intend to fix this behavior such that parse server will close all open connections and initiate the shutdown process as soon as it receives a SIGINT/SIGTERM signal. */ + server.on('connection', socket => { + const socketId = socket.remoteAddress + ':' + socket.remotePort; + sockets[socketId] = socket; + socket.on('close', () => { + delete sockets[socketId]; + }); + }); + + const destroyAliveConnections = function () { + for (const socketId in sockets) { + try { + sockets[socketId].destroy(); + } catch (e) {/* */} + } + }; + + const handleShutdown = function () { + process.stdout.write('Termination signal received. Shutting down.'); + destroyAliveConnections(); + server.close(); + parseServer.handleShutdown(); + }; + process.on('SIGTERM', handleShutdown); + process.on('SIGINT', handleShutdown); +} + +exports.default = ParseServer; \ No newline at end of file diff --git a/lib/ParseServerRESTController.js b/lib/ParseServerRESTController.js new file mode 100644 index 0000000000..2ae687a32a --- /dev/null +++ b/lib/ParseServerRESTController.js @@ -0,0 +1,103 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +const Config = require('./Config'); +const Auth = require('./Auth'); +const RESTController = require('parse/lib/node/RESTController'); +const URL = require('url'); +const Parse = require('parse/node'); + +function getSessionToken(options) { + if (options && typeof options.sessionToken === 'string') { + return Parse.Promise.as(options.sessionToken); + } + return Parse.Promise.as(null); +} + +function getAuth(options = {}, config) { + const installationId = options.installationId || 'cloud'; + if (options.useMasterKey) { + return Parse.Promise.as(new Auth.Auth({ config, isMaster: true, installationId })); + } + return getSessionToken(options).then(sessionToken => { + if (sessionToken) { + options.sessionToken = sessionToken; + return Auth.getAuthForSessionToken({ + config, + sessionToken: sessionToken, + installationId + }); + } else { + return Parse.Promise.as(new Auth.Auth({ config, installationId })); + } + }); +} + +function ParseServerRESTController(applicationId, router) { + function handleRequest(method, path, data = {}, options = {}) { + // Store the arguments, for later use if internal fails + const args = arguments; + + const config = Config.get(applicationId); + const serverURL = URL.parse(config.serverURL); + if (path.indexOf(serverURL.path) === 0) { + path = path.slice(serverURL.path.length, path.length); + } + + if (path[0] !== "/") { + path = "/" + path; + } + + if (path === '/batch') { + const promises = data.requests.map(request => { + return handleRequest(request.method, request.path, request.body, options).then(response => { + return Parse.Promise.as({ success: response }); + }, error => { + return Parse.Promise.as({ error: { code: error.code, error: error.message } }); + }); + }); + return Parse.Promise.all(promises); + } + + let query; + if (method === 'GET') { + query = data; + } + + return new Parse.Promise((resolve, reject) => { + getAuth(options, config).then(auth => { + const request = { + body: data, + config, + auth, + info: { + applicationId: applicationId, + sessionToken: options.sessionToken + }, + query + }; + return Promise.resolve().then(() => { + return router.tryRouteRequest(method, path, request); + }).then(response => { + resolve(response.response, response.status, response); + }, err => { + if (err instanceof Parse.Error && err.code == Parse.Error.INVALID_JSON && err.message == `cannot route ${method} ${path}`) { + RESTController.request.apply(null, args).then(resolve, reject); + } else { + reject(err); + } + }); + }, reject); + }); + } + + return { + request: handleRequest, + ajax: RESTController.ajax + }; +} + +exports.default = ParseServerRESTController; +exports.ParseServerRESTController = ParseServerRESTController; \ No newline at end of file diff --git a/lib/PromiseRouter.js b/lib/PromiseRouter.js new file mode 100644 index 0000000000..120ec91d54 --- /dev/null +++ b/lib/PromiseRouter.js @@ -0,0 +1,218 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _express = require('express'); + +var _express2 = _interopRequireDefault(_express); + +var _logger = require('./logger'); + +var _logger2 = _interopRequireDefault(_logger); + +var _util = require('util'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// A router that is based on promises rather than req/res/next. +// This is intended to replace the use of express.Router to handle +// subsections of the API surface. +// This will make it easier to have methods like 'batch' that +// themselves use our routing information, without disturbing express +// components that external developers may be modifying. + +const Layer = require('express/lib/router/layer'); + +function validateParameter(key, value) { + if (key == 'className') { + if (value.match(/_?[A-Za-z][A-Za-z_0-9]*/)) { + return value; + } + } else if (key == 'objectId') { + if (value.match(/[A-Za-z0-9]+/)) { + return value; + } + } else { + return value; + } +} + +class PromiseRouter { + // Each entry should be an object with: + // path: the path to route, in express format + // method: the HTTP method that this route handles. + // Must be one of: POST, GET, PUT, DELETE + // handler: a function that takes request, and returns a promise. + // Successful handlers should resolve to an object with fields: + // status: optional. the http status code. defaults to 200 + // response: a json object with the content of the response + // location: optional. a location header + constructor(routes = [], appId) { + this.routes = routes; + this.appId = appId; + this.mountRoutes(); + } + + // Leave the opportunity to + // subclasses to mount their routes by overriding + mountRoutes() {} + + // Merge the routes into this one + merge(router) { + for (var route of router.routes) { + this.routes.push(route); + } + } + + route(method, path, ...handlers) { + switch (method) { + case 'POST': + case 'GET': + case 'PUT': + case 'DELETE': + break; + default: + throw 'cannot route method: ' + method; + } + + let handler = handlers[0]; + + if (handlers.length > 1) { + handler = function (req) { + return handlers.reduce((promise, handler) => { + return promise.then(() => { + return handler(req); + }); + }, Promise.resolve()); + }; + } + + this.routes.push({ + path: path, + method: method, + handler: handler, + layer: new Layer(path, null, handler) + }); + } + + // Returns an object with: + // handler: the handler that should deal with this request + // params: any :-params that got parsed from the path + // Returns undefined if there is no match. + match(method, path) { + for (var route of this.routes) { + if (route.method != method) { + continue; + } + const layer = route.layer || new Layer(route.path, null, route.handler); + const match = layer.match(path); + if (match) { + const params = layer.params; + Object.keys(params).forEach(key => { + params[key] = validateParameter(key, params[key]); + }); + return { params: params, handler: route.handler }; + } + } + } + + // Mount the routes on this router onto an express app (or express router) + mountOnto(expressApp) { + this.routes.forEach(route => { + const method = route.method.toLowerCase(); + const handler = makeExpressHandler(this.appId, route.handler); + expressApp[method].call(expressApp, route.path, handler); + }); + return expressApp; + } + + expressRouter() { + return this.mountOnto(_express2.default.Router()); + } + + tryRouteRequest(method, path, request) { + var match = this.match(method, path); + if (!match) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'cannot route ' + method + ' ' + path); + } + request.params = match.params; + return new Promise((resolve, reject) => { + match.handler(request).then(resolve, reject); + }); + } +} + +exports.default = PromiseRouter; // A helper function to make an express handler out of a a promise +// handler. +// Express handlers should never throw; if a promise handler throws we +// just treat it like it resolved to an error. + +function makeExpressHandler(appId, promiseHandler) { + return function (req, res, next) { + try { + const url = maskSensitiveUrl(req); + const body = Object.assign({}, req.body); + const method = req.method; + const headers = req.headers; + _logger2.default.logRequest({ + method, + url, + headers, + body + }); + promiseHandler(req).then(result => { + if (!result.response && !result.location && !result.text) { + _logger2.default.error('the handler did not include a "response" or a "location" field'); + throw 'control should not get here'; + } + + _logger2.default.logResponse({ method, url, result }); + + var status = result.status || 200; + res.status(status); + + if (result.text) { + res.send(result.text); + return; + } + + if (result.location) { + res.set('Location', result.location); + // Override the default expressjs response + // as it double encodes %encoded chars in URL + if (!result.response) { + res.send('Found. Redirecting to ' + result.location); + return; + } + } + if (result.headers) { + Object.keys(result.headers).forEach(header => { + res.set(header, result.headers[header]); + }); + } + res.json(result.response); + }, e => { + _logger2.default.error(`Error generating response. ${(0, _util.inspect)(e)}`, { error: e }); + next(e); + }); + } catch (e) { + _logger2.default.error(`Error handling request: ${(0, _util.inspect)(e)}`, { error: e }); + next(e); + } + }; +} + +function maskSensitiveUrl(req) { + let maskUrl = req.originalUrl.toString(); + const shouldMaskUrl = req.method === 'GET' && req.originalUrl.includes('/login') && !req.originalUrl.includes('classes'); + if (shouldMaskUrl) { + maskUrl = _logger2.default.maskSensitiveUrl(maskUrl); + } + return maskUrl; +} \ No newline at end of file diff --git a/lib/Push/PushQueue.js b/lib/Push/PushQueue.js new file mode 100644 index 0000000000..9566a939b4 --- /dev/null +++ b/lib/Push/PushQueue.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PushQueue = undefined; + +var _ParseMessageQueue = require('../ParseMessageQueue'); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _utils = require('./utils'); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const PUSH_CHANNEL = 'parse-server-push'; +const DEFAULT_BATCH_SIZE = 100; + +class PushQueue { + + // config object of the publisher, right now it only contains the redisURL, + // but we may extend it later. + constructor(config = {}) { + this.channel = config.channel || PushQueue.defaultPushChannel(); + this.batchSize = config.batchSize || DEFAULT_BATCH_SIZE; + this.parsePublisher = _ParseMessageQueue.ParseMessageQueue.createPublisher(config); + } + + static defaultPushChannel() { + return `${_node2.default.applicationId}-${PUSH_CHANNEL}`; + } + + enqueue(body, where, config, auth, pushStatus) { + const limit = this.batchSize; + + where = (0, _utils.applyDeviceTokenExists)(where); + + // Order by objectId so no impact on the DB + const order = 'objectId'; + return Promise.resolve().then(() => { + return _rest2.default.find(config, auth, '_Installation', where, { limit: 0, count: true }); + }).then(({ results, count }) => { + if (!results || count == 0) { + return Promise.reject({ error: 'PushController: no results in query' }); + } + pushStatus.setRunning(Math.ceil(count / limit)); + let skip = 0; + while (skip < count) { + const query = { where, + limit, + skip, + order }; + + const pushWorkItem = { + body, + query, + pushStatus: { objectId: pushStatus.objectId }, + applicationId: config.applicationId + }; + this.parsePublisher.publish(this.channel, JSON.stringify(pushWorkItem)); + skip += limit; + } + }); + } +} +exports.PushQueue = PushQueue; \ No newline at end of file diff --git a/lib/Push/PushWorker.js b/lib/Push/PushWorker.js new file mode 100644 index 0000000000..14060e558c --- /dev/null +++ b/lib/Push/PushWorker.js @@ -0,0 +1,149 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PushWorker = undefined; + +var _deepcopy = require('deepcopy'); + +var _deepcopy2 = _interopRequireDefault(_deepcopy); + +var _AdaptableController = require('../Controllers/AdaptableController'); + +var _AdaptableController2 = _interopRequireDefault(_AdaptableController); + +var _Auth = require('../Auth'); + +var _Config = require('../Config'); + +var _Config2 = _interopRequireDefault(_Config); + +var _PushAdapter = require('../Adapters/Push/PushAdapter'); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _StatusHandler = require('../StatusHandler'); + +var _utils = require('./utils'); + +var utils = _interopRequireWildcard(_utils); + +var _ParseMessageQueue = require('../ParseMessageQueue'); + +var _PushQueue = require('./PushQueue'); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function groupByBadge(installations) { + return installations.reduce((map, installation) => { + const badge = installation.badge + ''; + map[badge] = map[badge] || []; + map[badge].push(installation); + return map; + }, {}); +} +class PushWorker { + + constructor(pushAdapter, subscriberConfig = {}) { + _AdaptableController2.default.validateAdapter(pushAdapter, this, _PushAdapter.PushAdapter); + this.adapter = pushAdapter; + + this.channel = subscriberConfig.channel || _PushQueue.PushQueue.defaultPushChannel(); + this.subscriber = _ParseMessageQueue.ParseMessageQueue.createSubscriber(subscriberConfig); + if (this.subscriber) { + const subscriber = this.subscriber; + subscriber.subscribe(this.channel); + subscriber.on('message', (channel, messageStr) => { + const workItem = JSON.parse(messageStr); + this.getAndRun(workItem); + }); + } + } + + unsubscribe() { + if (this.subscriber) { + this.subscriber.unsubscribe(this.channel); + } + } + + run({ body, query, pushStatus, applicationId, UTCOffset }) { + const config = _Config2.default.get(applicationId); + const auth = (0, _Auth.master)(config); + const where = utils.applyDeviceTokenExists(query.where); + delete query.where; + pushStatus = (0, _StatusHandler.pushStatusHandler)(config, pushStatus.objectId); + return _rest2.default.find(config, auth, '_Installation', where, query).then(({ results }) => { + if (results.length == 0) { + return pushStatus.trackSent(results); + } + return this.sendToAdapter(body, results, pushStatus, config, UTCOffset); + }, err => { + throw err; + }); + } + + sendToAdapter(body, installations, pushStatus, config, UTCOffset) { + // Check if we have locales in the push body + const locales = utils.getLocalesFromPush(body); + if (locales.length > 0) { + // Get all tranformed bodies for each locale + const bodiesPerLocales = utils.bodiesPerLocales(body, locales); + + // Group installations on the specified locales (en, fr, default etc...) + const grouppedInstallations = utils.groupByLocaleIdentifier(installations, locales); + const promises = Object.keys(grouppedInstallations).map(locale => { + const installations = grouppedInstallations[locale]; + const body = bodiesPerLocales[locale]; + return this.sendToAdapter(body, installations, pushStatus, config, UTCOffset); + }); + return Promise.all(promises); + } + + if (!utils.isPushIncrementing(body)) { + _logger2.default.verbose(`Sending push to ${installations.length}`); + return this.adapter.send(body, installations, pushStatus.objectId).then(results => { + return pushStatus.trackSent(results, UTCOffset, undefined, installations.length - results.length).then(() => results); + }); + } + + // Collect the badges to reduce the # of calls + const badgeInstallationsMap = groupByBadge(installations); + + // Map the on the badges count and return the send result + const promises = Object.keys(badgeInstallationsMap).map(badge => { + const payload = (0, _deepcopy2.default)(body); + payload.data.badge = parseInt(badge); + const installations = badgeInstallationsMap[badge]; + return this.sendToAdapter(payload, installations, pushStatus, config, UTCOffset); + }); + return Promise.all(promises); + } + + getAndRun(workItem) { + var _this = this; + if (!_this.subscriber.run) { + return _this.run(workItem); + } + return _this.subscriber.run(workItem).then(function (gotItem) { + if (gotItem) { + return _this.run(gotItem).then(function () { + return _this.getAndRun(gotItem); + }); + } else { + return Promise.resolve(); + } + }); + } +} + +exports.PushWorker = PushWorker; +exports.default = PushWorker; \ No newline at end of file diff --git a/lib/Push/utils.js b/lib/Push/utils.js new file mode 100644 index 0000000000..a526977766 --- /dev/null +++ b/lib/Push/utils.js @@ -0,0 +1,133 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isPushIncrementing = isPushIncrementing; +exports.getLocalesFromPush = getLocalesFromPush; +exports.transformPushBodyForLocale = transformPushBodyForLocale; +exports.stripLocalesFromBody = stripLocalesFromBody; +exports.bodiesPerLocales = bodiesPerLocales; +exports.groupByLocaleIdentifier = groupByLocaleIdentifier; +exports.validatePushType = validatePushType; +exports.applyDeviceTokenExists = applyDeviceTokenExists; + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _deepcopy = require('deepcopy'); + +var _deepcopy2 = _interopRequireDefault(_deepcopy); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function isPushIncrementing(body) { + return body.data && body.data.badge && typeof body.data.badge == 'string' && body.data.badge.toLowerCase() == "increment"; +} + +const localizableKeys = ['alert', 'title']; + +function getLocalesFromPush(body) { + const data = body.data; + if (!data) { + return []; + } + return [...new Set(Object.keys(data).reduce((memo, key) => { + localizableKeys.forEach(localizableKey => { + if (key.indexOf(`${localizableKey}-`) == 0) { + memo.push(key.slice(localizableKey.length + 1)); + } + }); + return memo; + }, []))]; +} + +function transformPushBodyForLocale(body, locale) { + const data = body.data; + if (!data) { + return body; + } + body = (0, _deepcopy2.default)(body); + localizableKeys.forEach(key => { + const localeValue = body.data[`${key}-${locale}`]; + if (localeValue) { + body.data[key] = localeValue; + } + }); + return stripLocalesFromBody(body); +} + +function stripLocalesFromBody(body) { + if (!body.data) { + return body; + } + Object.keys(body.data).forEach(key => { + localizableKeys.forEach(localizableKey => { + if (key.indexOf(`${localizableKey}-`) == 0) { + delete body.data[key]; + } + }); + }); + return body; +} + +function bodiesPerLocales(body, locales = []) { + // Get all tranformed bodies for each locale + const result = locales.reduce((memo, locale) => { + memo[locale] = transformPushBodyForLocale(body, locale); + return memo; + }, {}); + // Set the default locale, with the stripped body + result.default = stripLocalesFromBody(body); + return result; +} + +function groupByLocaleIdentifier(installations, locales = []) { + return installations.reduce((map, installation) => { + let added = false; + locales.forEach(locale => { + if (added) { + return; + } + if (installation.localeIdentifier && installation.localeIdentifier.indexOf(locale) === 0) { + added = true; + map[locale] = map[locale] || []; + map[locale].push(installation); + } + }); + if (!added) { + map.default.push(installation); + } + return map; + }, { default: [] }); +} + +/** + * Check whether the deviceType parameter in qury condition is valid or not. + * @param {Object} where A query condition + * @param {Array} validPushTypes An array of valid push types(string) + */ +function validatePushType(where = {}, validPushTypes = []) { + var deviceTypeField = where.deviceType || {}; + var deviceTypes = []; + if (typeof deviceTypeField === 'string') { + deviceTypes.push(deviceTypeField); + } else if (Array.isArray(deviceTypeField['$in'])) { + deviceTypes.concat(deviceTypeField['$in']); + } + for (var i = 0; i < deviceTypes.length; i++) { + var deviceType = deviceTypes[i]; + if (validPushTypes.indexOf(deviceType) < 0) { + throw new _node2.default.Error(_node2.default.Error.PUSH_MISCONFIGURED, deviceType + ' is not supported push type.'); + } + } +} + +function applyDeviceTokenExists(where) { + where = (0, _deepcopy2.default)(where); + if (!where.hasOwnProperty('deviceToken')) { + where['deviceToken'] = { '$exists': true }; + } + return where; +} \ No newline at end of file diff --git a/lib/RestQuery.js b/lib/RestQuery.js new file mode 100644 index 0000000000..7478200467 --- /dev/null +++ b/lib/RestQuery.js @@ -0,0 +1,752 @@ +'use strict'; + +// An object that encapsulates everything we need to run a 'find' +// operation, encoded in the REST API format. + +var SchemaController = require('./Controllers/SchemaController'); +var Parse = require('parse/node').Parse; +const triggers = require('./triggers'); + +const AlwaysSelectedKeys = ['objectId', 'createdAt', 'updatedAt']; +// restOptions can include: +// skip +// limit +// order +// count +// include +// keys +// redirectClassNameForKey +function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, clientSDK) { + + this.config = config; + this.auth = auth; + this.className = className; + this.restWhere = restWhere; + this.restOptions = restOptions; + this.clientSDK = clientSDK; + this.response = null; + this.findOptions = {}; + if (!this.auth.isMaster) { + this.findOptions.acl = this.auth.user ? [this.auth.user.id] : null; + if (this.className == '_Session') { + if (!this.findOptions.acl) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'This session token is invalid.'); + } + this.restWhere = { + '$and': [this.restWhere, { + 'user': { + __type: 'Pointer', + className: '_User', + objectId: this.auth.user.id + } + }] + }; + } + } + + this.doCount = false; + + // The format for this.include is not the same as the format for the + // include option - it's the paths we should include, in order, + // stored as arrays, taking into account that we need to include foo + // before including foo.bar. Also it should dedupe. + // For example, passing an arg of include=foo.bar,foo.baz could lead to + // this.include = [['foo'], ['foo', 'baz'], ['foo', 'bar']] + this.include = []; + + // If we have keys, we probably want to force some includes (n-1 level) + // See issue: https://github.com/parse-community/parse-server/issues/3185 + if (restOptions.hasOwnProperty('keys')) { + const keysForInclude = restOptions.keys.split(',').filter(key => { + // At least 2 components + return key.split(".").length > 1; + }).map(key => { + // Slice the last component (a.b.c -> a.b) + // Otherwise we'll include one level too much. + return key.slice(0, key.lastIndexOf(".")); + }).join(','); + + // Concat the possibly present include string with the one from the keys + // Dedup / sorting is handle in 'include' case. + if (keysForInclude.length > 0) { + if (!restOptions.include || restOptions.include.length == 0) { + restOptions.include = keysForInclude; + } else { + restOptions.include += "," + keysForInclude; + } + } + } + + for (var option in restOptions) { + switch (option) { + case 'keys': + { + const keys = restOptions.keys.split(',').concat(AlwaysSelectedKeys); + this.keys = Array.from(new Set(keys)); + break; + } + case 'count': + this.doCount = true; + break; + case 'distinct': + case 'pipeline': + case 'skip': + case 'limit': + case 'readPreference': + this.findOptions[option] = restOptions[option]; + break; + case 'order': + var fields = restOptions.order.split(','); + this.findOptions.sort = fields.reduce((sortMap, field) => { + field = field.trim(); + if (field === '$score') { + sortMap.score = { $meta: 'textScore' }; + } else if (field[0] == '-') { + sortMap[field.slice(1)] = -1; + } else { + sortMap[field] = 1; + } + return sortMap; + }, {}); + break; + case 'include': + { + const paths = restOptions.include.split(','); + // Load the existing includes (from keys) + const pathSet = paths.reduce((memo, path) => { + // Split each paths on . (a.b.c -> [a,b,c]) + // reduce to create all paths + // ([a,b,c] -> {a: true, 'a.b': true, 'a.b.c': true}) + return path.split('.').reduce((memo, path, index, parts) => { + memo[parts.slice(0, index + 1).join('.')] = true; + return memo; + }, memo); + }, {}); + + this.include = Object.keys(pathSet).map(s => { + return s.split('.'); + }).sort((a, b) => { + return a.length - b.length; // Sort by number of components + }); + break; + } + case 'redirectClassNameForKey': + this.redirectKey = restOptions.redirectClassNameForKey; + this.redirectClassName = null; + break; + case 'includeReadPreference': + case 'subqueryReadPreference': + break; + default: + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad option: ' + option); + } + } +} + +// A convenient method to perform all the steps of processing a query +// in order. +// Returns a promise for the response - an object with optional keys +// 'results' and 'count'. +// TODO: consolidate the replaceX functions +RestQuery.prototype.execute = function (executeOptions) { + return Promise.resolve().then(() => { + return this.buildRestWhere(); + }).then(() => { + return this.runFind(executeOptions); + }).then(() => { + return this.runCount(); + }).then(() => { + return this.handleInclude(); + }).then(() => { + return this.runAfterFindTrigger(); + }).then(() => { + return this.response; + }); +}; + +RestQuery.prototype.buildRestWhere = function () { + return Promise.resolve().then(() => { + return this.getUserAndRoleACL(); + }).then(() => { + return this.redirectClassNameForKey(); + }).then(() => { + return this.validateClientClassCreation(); + }).then(() => { + return this.replaceSelect(); + }).then(() => { + return this.replaceDontSelect(); + }).then(() => { + return this.replaceInQuery(); + }).then(() => { + return this.replaceNotInQuery(); + }).then(() => { + return this.replaceEquality(); + }); +}; + +// Uses the Auth object to get the list of roles, adds the user id +RestQuery.prototype.getUserAndRoleACL = function () { + if (this.auth.isMaster || !this.auth.user) { + return Promise.resolve(); + } + return this.auth.getUserRoles().then(roles => { + // Concat with the roles to prevent duplications on multiple calls + const aclSet = new Set([].concat(this.findOptions.acl, roles)); + this.findOptions.acl = Array.from(aclSet); + return Promise.resolve(); + }); +}; + +// Changes the className if redirectClassNameForKey is set. +// Returns a promise. +RestQuery.prototype.redirectClassNameForKey = function () { + if (!this.redirectKey) { + return Promise.resolve(); + } + + // We need to change the class name based on the schema + return this.config.database.redirectClassNameForKey(this.className, this.redirectKey).then(newClassName => { + this.className = newClassName; + this.redirectClassName = newClassName; + }); +}; + +// Validates this operation against the allowClientClassCreation config. +RestQuery.prototype.validateClientClassCreation = function () { + if (this.config.allowClientClassCreation === false && !this.auth.isMaster && SchemaController.systemClasses.indexOf(this.className) === -1) { + return this.config.database.loadSchema().then(schemaController => schemaController.hasClass(this.className)).then(hasClass => { + if (hasClass !== true) { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'This user is not allowed to access ' + 'non-existent class: ' + this.className); + } + }); + } else { + return Promise.resolve(); + } +}; + +function transformInQuery(inQueryObject, className, results) { + var values = []; + for (var result of results) { + values.push({ + __type: 'Pointer', + className: className, + objectId: result.objectId + }); + } + delete inQueryObject['$inQuery']; + if (Array.isArray(inQueryObject['$in'])) { + inQueryObject['$in'] = inQueryObject['$in'].concat(values); + } else { + inQueryObject['$in'] = values; + } +} + +// Replaces a $inQuery clause by running the subquery, if there is an +// $inQuery clause. +// The $inQuery clause turns into an $in with values that are just +// pointers to the objects returned in the subquery. +RestQuery.prototype.replaceInQuery = function () { + var inQueryObject = findObjectWithKey(this.restWhere, '$inQuery'); + if (!inQueryObject) { + return; + } + + // The inQuery value must have precisely two keys - where and className + var inQueryValue = inQueryObject['$inQuery']; + if (!inQueryValue.where || !inQueryValue.className) { + throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $inQuery'); + } + + const additionalOptions = { + redirectClassNameForKey: inQueryValue.redirectClassNameForKey, + keys: 'objectId' + }; + + if (this.restOptions.subqueryReadPreference) { + additionalOptions.readPreference = this.restOptions.subqueryReadPreference; + additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference; + } + + var subquery = new RestQuery(this.config, this.auth, inQueryValue.className, inQueryValue.where, additionalOptions); + return subquery.execute().then(response => { + transformInQuery(inQueryObject, subquery.className, response.results); + // Recurse to repeat + return this.replaceInQuery(); + }); +}; + +function transformNotInQuery(notInQueryObject, className, results) { + var values = []; + for (var result of results) { + values.push({ + __type: 'Pointer', + className: className, + objectId: result.objectId + }); + } + delete notInQueryObject['$notInQuery']; + if (Array.isArray(notInQueryObject['$nin'])) { + notInQueryObject['$nin'] = notInQueryObject['$nin'].concat(values); + } else { + notInQueryObject['$nin'] = values; + } +} + +// Replaces a $notInQuery clause by running the subquery, if there is an +// $notInQuery clause. +// The $notInQuery clause turns into a $nin with values that are just +// pointers to the objects returned in the subquery. +RestQuery.prototype.replaceNotInQuery = function () { + var notInQueryObject = findObjectWithKey(this.restWhere, '$notInQuery'); + if (!notInQueryObject) { + return; + } + + // The notInQuery value must have precisely two keys - where and className + var notInQueryValue = notInQueryObject['$notInQuery']; + if (!notInQueryValue.where || !notInQueryValue.className) { + throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $notInQuery'); + } + + const additionalOptions = { + redirectClassNameForKey: notInQueryValue.redirectClassNameForKey, + keys: 'objectId' + }; + + if (this.restOptions.subqueryReadPreference) { + additionalOptions.readPreference = this.restOptions.subqueryReadPreference; + additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference; + } + + var subquery = new RestQuery(this.config, this.auth, notInQueryValue.className, notInQueryValue.where, additionalOptions); + return subquery.execute().then(response => { + transformNotInQuery(notInQueryObject, subquery.className, response.results); + // Recurse to repeat + return this.replaceNotInQuery(); + }); +}; + +const transformSelect = (selectObject, key, objects) => { + var values = []; + for (var result of objects) { + values.push(key.split('.').reduce((o, i) => o[i], result)); + } + delete selectObject['$select']; + if (Array.isArray(selectObject['$in'])) { + selectObject['$in'] = selectObject['$in'].concat(values); + } else { + selectObject['$in'] = values; + } +}; + +// Replaces a $select clause by running the subquery, if there is a +// $select clause. +// The $select clause turns into an $in with values selected out of +// the subquery. +// Returns a possible-promise. +RestQuery.prototype.replaceSelect = function () { + var selectObject = findObjectWithKey(this.restWhere, '$select'); + if (!selectObject) { + return; + } + + // The select value must have precisely two keys - query and key + var selectValue = selectObject['$select']; + // iOS SDK don't send where if not set, let it pass + if (!selectValue.query || !selectValue.key || typeof selectValue.query !== 'object' || !selectValue.query.className || Object.keys(selectValue).length !== 2) { + throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $select'); + } + + const additionalOptions = { + redirectClassNameForKey: selectValue.query.redirectClassNameForKey, + keys: selectValue.key + }; + + if (this.restOptions.subqueryReadPreference) { + additionalOptions.readPreference = this.restOptions.subqueryReadPreference; + additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference; + } + + var subquery = new RestQuery(this.config, this.auth, selectValue.query.className, selectValue.query.where, additionalOptions); + return subquery.execute().then(response => { + transformSelect(selectObject, selectValue.key, response.results); + // Keep replacing $select clauses + return this.replaceSelect(); + }); +}; + +const transformDontSelect = (dontSelectObject, key, objects) => { + var values = []; + for (var result of objects) { + values.push(key.split('.').reduce((o, i) => o[i], result)); + } + delete dontSelectObject['$dontSelect']; + if (Array.isArray(dontSelectObject['$nin'])) { + dontSelectObject['$nin'] = dontSelectObject['$nin'].concat(values); + } else { + dontSelectObject['$nin'] = values; + } +}; + +// Replaces a $dontSelect clause by running the subquery, if there is a +// $dontSelect clause. +// The $dontSelect clause turns into an $nin with values selected out of +// the subquery. +// Returns a possible-promise. +RestQuery.prototype.replaceDontSelect = function () { + var dontSelectObject = findObjectWithKey(this.restWhere, '$dontSelect'); + if (!dontSelectObject) { + return; + } + + // The dontSelect value must have precisely two keys - query and key + var dontSelectValue = dontSelectObject['$dontSelect']; + if (!dontSelectValue.query || !dontSelectValue.key || typeof dontSelectValue.query !== 'object' || !dontSelectValue.query.className || Object.keys(dontSelectValue).length !== 2) { + throw new Parse.Error(Parse.Error.INVALID_QUERY, 'improper usage of $dontSelect'); + } + const additionalOptions = { + redirectClassNameForKey: dontSelectValue.query.redirectClassNameForKey, + keys: dontSelectValue.key + }; + + if (this.restOptions.subqueryReadPreference) { + additionalOptions.readPreference = this.restOptions.subqueryReadPreference; + additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference; + } + + var subquery = new RestQuery(this.config, this.auth, dontSelectValue.query.className, dontSelectValue.query.where, additionalOptions); + return subquery.execute().then(response => { + transformDontSelect(dontSelectObject, dontSelectValue.key, response.results); + // Keep replacing $dontSelect clauses + return this.replaceDontSelect(); + }); +}; + +const cleanResultOfSensitiveUserInfo = function (result, auth, config) { + delete result.password; + + if (auth.isMaster || auth.user && auth.user.id === result.objectId) { + return; + } + + for (const field of config.userSensitiveFields) { + delete result[field]; + } +}; + +const cleanResultAuthData = function (result) { + if (result.authData) { + Object.keys(result.authData).forEach(provider => { + if (result.authData[provider] === null) { + delete result.authData[provider]; + } + }); + + if (Object.keys(result.authData).length == 0) { + delete result.authData; + } + } +}; + +const replaceEqualityConstraint = constraint => { + if (typeof constraint !== 'object') { + return constraint; + } + const equalToObject = {}; + let hasDirectConstraint = false; + let hasOperatorConstraint = false; + for (const key in constraint) { + if (key.indexOf('$') !== 0) { + hasDirectConstraint = true; + equalToObject[key] = constraint[key]; + } else { + hasOperatorConstraint = true; + } + } + if (hasDirectConstraint && hasOperatorConstraint) { + constraint['$eq'] = equalToObject; + Object.keys(equalToObject).forEach(key => { + delete constraint[key]; + }); + } + return constraint; +}; + +RestQuery.prototype.replaceEquality = function () { + if (typeof this.restWhere !== 'object') { + return; + } + for (const key in this.restWhere) { + this.restWhere[key] = replaceEqualityConstraint(this.restWhere[key]); + } +}; + +// Returns a promise for whether it was successful. +// Populates this.response with an object that only has 'results'. +RestQuery.prototype.runFind = function (options = {}) { + if (this.findOptions.limit === 0) { + this.response = { results: [] }; + return Promise.resolve(); + } + const findOptions = Object.assign({}, this.findOptions); + if (this.keys) { + findOptions.keys = this.keys.map(key => { + return key.split('.')[0]; + }); + } + if (options.op) { + findOptions.op = options.op; + } + return this.config.database.find(this.className, this.restWhere, findOptions).then(results => { + if (this.className === '_User') { + for (var result of results) { + cleanResultOfSensitiveUserInfo(result, this.auth, this.config); + cleanResultAuthData(result); + } + } + + this.config.filesController.expandFilesInObject(this.config, results); + + if (this.redirectClassName) { + for (var r of results) { + r.className = this.redirectClassName; + } + } + this.response = { results: results }; + }); +}; + +// Returns a promise for whether it was successful. +// Populates this.response.count with the count +RestQuery.prototype.runCount = function () { + if (!this.doCount) { + return; + } + this.findOptions.count = true; + delete this.findOptions.skip; + delete this.findOptions.limit; + return this.config.database.find(this.className, this.restWhere, this.findOptions).then(c => { + this.response.count = c; + }); +}; + +// Augments this.response with data at the paths provided in this.include. +RestQuery.prototype.handleInclude = function () { + if (this.include.length == 0) { + return; + } + + var pathResponse = includePath(this.config, this.auth, this.response, this.include[0], this.restOptions); + if (pathResponse.then) { + return pathResponse.then(newResponse => { + this.response = newResponse; + this.include = this.include.slice(1); + return this.handleInclude(); + }); + } else if (this.include.length > 0) { + this.include = this.include.slice(1); + return this.handleInclude(); + } + + return pathResponse; +}; + +//Returns a promise of a processed set of results +RestQuery.prototype.runAfterFindTrigger = function () { + if (!this.response) { + return; + } + // Avoid doing any setup for triggers if there is no 'afterFind' trigger for this class. + const hasAfterFindHook = triggers.triggerExists(this.className, triggers.Types.afterFind, this.config.applicationId); + if (!hasAfterFindHook) { + return Promise.resolve(); + } + // Run afterFind trigger and set the new results + return triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, this.auth, this.className, this.response.results, this.config).then(results => { + this.response.results = results; + }); +}; + +// Adds included values to the response. +// Path is a list of field names. +// Returns a promise for an augmented response. +function includePath(config, auth, response, path, restOptions = {}) { + var pointers = findPointers(response.results, path); + if (pointers.length == 0) { + return response; + } + const pointersHash = {}; + for (var pointer of pointers) { + if (!pointer) { + continue; + } + const className = pointer.className; + // only include the good pointers + if (className) { + pointersHash[className] = pointersHash[className] || new Set(); + pointersHash[className].add(pointer.objectId); + } + } + const includeRestOptions = {}; + if (restOptions.keys) { + const keys = new Set(restOptions.keys.split(',')); + const keySet = Array.from(keys).reduce((set, key) => { + const keyPath = key.split('.'); + let i = 0; + for (i; i < path.length; i++) { + if (path[i] != keyPath[i]) { + return set; + } + } + if (i < keyPath.length) { + set.add(keyPath[i]); + } + return set; + }, new Set()); + if (keySet.size > 0) { + includeRestOptions.keys = Array.from(keySet).join(','); + } + } + + if (restOptions.includeReadPreference) { + includeRestOptions.readPreference = restOptions.includeReadPreference; + includeRestOptions.includeReadPreference = restOptions.includeReadPreference; + } + + const queryPromises = Object.keys(pointersHash).map(className => { + const objectIds = Array.from(pointersHash[className]); + let where; + if (objectIds.length === 1) { + where = { 'objectId': objectIds[0] }; + } else { + where = { 'objectId': { '$in': objectIds } }; + } + var query = new RestQuery(config, auth, className, where, includeRestOptions); + return query.execute({ op: 'get' }).then(results => { + results.className = className; + return Promise.resolve(results); + }); + }); + + // Get the objects for all these object ids + return Promise.all(queryPromises).then(responses => { + var replace = responses.reduce((replace, includeResponse) => { + for (var obj of includeResponse.results) { + obj.__type = 'Object'; + obj.className = includeResponse.className; + + if (obj.className == "_User" && !auth.isMaster) { + delete obj.sessionToken; + delete obj.authData; + } + replace[obj.objectId] = obj; + } + return replace; + }, {}); + + var resp = { + results: replacePointers(response.results, path, replace) + }; + if (response.count) { + resp.count = response.count; + } + return resp; + }); +} + +// Object may be a list of REST-format object to find pointers in, or +// it may be a single object. +// If the path yields things that aren't pointers, this throws an error. +// Path is a list of fields to search into. +// Returns a list of pointers in REST format. +function findPointers(object, path) { + if (object instanceof Array) { + var answer = []; + for (var x of object) { + answer = answer.concat(findPointers(x, path)); + } + return answer; + } + + if (typeof object !== 'object' || !object) { + return []; + } + + if (path.length == 0) { + if (object === null || object.__type == 'Pointer') { + return [object]; + } + return []; + } + + var subobject = object[path[0]]; + if (!subobject) { + return []; + } + return findPointers(subobject, path.slice(1)); +} + +// Object may be a list of REST-format objects to replace pointers +// in, or it may be a single object. +// Path is a list of fields to search into. +// replace is a map from object id -> object. +// Returns something analogous to object, but with the appropriate +// pointers inflated. +function replacePointers(object, path, replace) { + if (object instanceof Array) { + return object.map(obj => replacePointers(obj, path, replace)).filter(obj => typeof obj !== 'undefined'); + } + + if (typeof object !== 'object' || !object) { + return object; + } + + if (path.length === 0) { + if (object && object.__type === 'Pointer') { + return replace[object.objectId]; + } + return object; + } + + var subobject = object[path[0]]; + if (!subobject) { + return object; + } + var newsub = replacePointers(subobject, path.slice(1), replace); + var answer = {}; + for (var key in object) { + if (key == path[0]) { + answer[key] = newsub; + } else { + answer[key] = object[key]; + } + } + return answer; +} + +// Finds a subobject that has the given key, if there is one. +// Returns undefined otherwise. +function findObjectWithKey(root, key) { + if (typeof root !== 'object') { + return; + } + if (root instanceof Array) { + for (var item of root) { + const answer = findObjectWithKey(item, key); + if (answer) { + return answer; + } + } + } + if (root && root[key]) { + return root; + } + for (var subkey in root) { + const answer = findObjectWithKey(root[subkey], key); + if (answer) { + return answer; + } + } +} + +module.exports = RestQuery; \ No newline at end of file diff --git a/lib/RestWrite.js b/lib/RestWrite.js new file mode 100644 index 0000000000..b763f7d00d --- /dev/null +++ b/lib/RestWrite.js @@ -0,0 +1,1178 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _RestQuery = require('./RestQuery'); + +var _RestQuery2 = _interopRequireDefault(_RestQuery); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _logger = require('./logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// A RestWrite encapsulates everything we need to run an operation +// that writes to the database. +// This could be either a "create" or an "update". + +var SchemaController = require('./Controllers/SchemaController'); +var deepcopy = require('deepcopy'); + +var Auth = require('./Auth'); +var cryptoUtils = require('./cryptoUtils'); +var passwordCrypto = require('./password'); +var Parse = require('parse/node'); +var triggers = require('./triggers'); +var ClientSDK = require('./ClientSDK'); + + +// query and data are both provided in REST API format. So data +// types are encoded by plain old objects. +// If query is null, this is a "create" and the data in data should be +// created. +// Otherwise this is an "update" - the object matching the query +// should get updated with data. +// RestWrite will handle objectId, createdAt, and updatedAt for +// everything. It also knows to use triggers and special modifications +// for the _User class. +function RestWrite(config, auth, className, query, data, originalData, clientSDK, options) { + if (auth.isReadOnly) { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform a write operation when using readOnlyMasterKey'); + } + this.config = config; + this.auth = auth; + this.className = className; + this.clientSDK = clientSDK; + this.storage = {}; + this.runOptions = {}; + const allowObjectId = options && options.allowObjectId === true; + if (!query && data.objectId && !allowObjectId) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.'); + } + + // When the operation is complete, this.response may have several + // fields. + // response: the actual data to be returned + // status: the http status code. if not present, treated like a 200 + // location: the location header. if not present, no location header + this.response = null; + + // Processing this operation may mutate our data, so we operate on a + // copy + this.query = deepcopy(query); + this.data = deepcopy(data); + // We never change originalData, so we do not need a deep copy + this.originalData = originalData; + + // The timestamp we'll use for this whole operation + this.updatedAt = Parse._encode(new Date()).iso; +} + +// A convenient method to perform all the steps of processing the +// write, in order. +// Returns a promise for a {response, status, location} object. +// status and location are optional. +RestWrite.prototype.execute = function () { + return Promise.resolve().then(() => { + return this.getUserAndRoleACL(); + }).then(() => { + return this.validateClientClassCreation(); + }).then(() => { + return this.handleInstallation(); + }).then(() => { + return this.handleSession(); + }).then(() => { + return this.validateAuthData(); + }).then(() => { + return this.runBeforeTrigger(); + }).then(() => { + return this.validateSchema(); + }).then(() => { + return this.setRequiredFieldsIfNeeded(); + }).then(() => { + return this.transformUser(); + }).then(() => { + return this.expandFilesForExistingObjects(); + }).then(() => { + return this.destroyDuplicatedSessions(); + }).then(() => { + return this.runDatabaseOperation(); + }).then(() => { + return this.createSessionTokenIfNeeded(); + }).then(() => { + return this.handleFollowup(); + }).then(() => { + return this.runAfterTrigger(); + }).then(() => { + return this.cleanUserAuthData(); + }).then(() => { + return this.response; + }); +}; + +// Uses the Auth object to get the list of roles, adds the user id +RestWrite.prototype.getUserAndRoleACL = function () { + if (this.auth.isMaster) { + return Promise.resolve(); + } + + this.runOptions.acl = ['*']; + + if (this.auth.user) { + return this.auth.getUserRoles().then(roles => { + this.runOptions.acl = this.runOptions.acl.concat(roles, [this.auth.user.id]); + return; + }); + } else { + return Promise.resolve(); + } +}; + +// Validates this operation against the allowClientClassCreation config. +RestWrite.prototype.validateClientClassCreation = function () { + if (this.config.allowClientClassCreation === false && !this.auth.isMaster && SchemaController.systemClasses.indexOf(this.className) === -1) { + return this.config.database.loadSchema().then(schemaController => schemaController.hasClass(this.className)).then(hasClass => { + if (hasClass !== true) { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'This user is not allowed to access ' + 'non-existent class: ' + this.className); + } + }); + } else { + return Promise.resolve(); + } +}; + +// Validates this operation against the schema. +RestWrite.prototype.validateSchema = function () { + return this.config.database.validateObject(this.className, this.data, this.query, this.runOptions); +}; + +// Runs any beforeSave triggers against this operation. +// Any change leads to our data being mutated. +RestWrite.prototype.runBeforeTrigger = function () { + if (this.response) { + return; + } + + // Avoid doing any setup for triggers if there is no 'beforeSave' trigger for this class. + if (!triggers.triggerExists(this.className, triggers.Types.beforeSave, this.config.applicationId)) { + return Promise.resolve(); + } + + // Cloud code gets a bit of extra data for its objects + var extraData = { className: this.className }; + if (this.query && this.query.objectId) { + extraData.objectId = this.query.objectId; + } + + let originalObject = null; + const updatedObject = this.buildUpdatedObject(extraData); + if (this.query && this.query.objectId) { + // This is an update for existing object. + originalObject = triggers.inflate(extraData, this.originalData); + } + + return Promise.resolve().then(() => { + return triggers.maybeRunTrigger(triggers.Types.beforeSave, this.auth, updatedObject, originalObject, this.config); + }).then(response => { + if (response && response.object) { + this.storage.fieldsChangedByTrigger = _lodash2.default.reduce(response.object, (result, value, key) => { + if (!_lodash2.default.isEqual(this.data[key], value)) { + result.push(key); + } + return result; + }, []); + this.data = response.object; + // We should delete the objectId for an update write + if (this.query && this.query.objectId) { + delete this.data.objectId; + } + } + }); +}; + +RestWrite.prototype.setRequiredFieldsIfNeeded = function () { + if (this.data) { + // Add default fields + this.data.updatedAt = this.updatedAt; + if (!this.query) { + this.data.createdAt = this.updatedAt; + + // Only assign new objectId if we are creating new object + if (!this.data.objectId) { + this.data.objectId = cryptoUtils.newObjectId(this.config.objectIdSize); + } + } + } + return Promise.resolve(); +}; + +// Transforms auth data for a user object. +// Does nothing if this isn't a user object. +// Returns a promise for when we're done if it can't finish this tick. +RestWrite.prototype.validateAuthData = function () { + if (this.className !== '_User') { + return; + } + + if (!this.query && !this.data.authData) { + if (typeof this.data.username !== 'string' || _lodash2.default.isEmpty(this.data.username)) { + throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'bad or missing username'); + } + if (typeof this.data.password !== 'string' || _lodash2.default.isEmpty(this.data.password)) { + throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required'); + } + } + + if (!this.data.authData || !Object.keys(this.data.authData).length) { + return; + } + + var authData = this.data.authData; + var providers = Object.keys(authData); + if (providers.length > 0) { + const canHandleAuthData = providers.reduce((canHandle, provider) => { + var providerAuthData = authData[provider]; + var hasToken = providerAuthData && providerAuthData.id; + return canHandle && (hasToken || providerAuthData == null); + }, true); + if (canHandleAuthData) { + return this.handleAuthData(authData); + } + } + throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE, 'This authentication method is unsupported.'); +}; + +RestWrite.prototype.handleAuthDataValidation = function (authData) { + const validations = Object.keys(authData).map(provider => { + if (authData[provider] === null) { + return Promise.resolve(); + } + const validateAuthData = this.config.authDataManager.getValidatorForProvider(provider); + if (!validateAuthData) { + throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE, 'This authentication method is unsupported.'); + } + return validateAuthData(authData[provider]); + }); + return Promise.all(validations); +}; + +RestWrite.prototype.findUsersWithAuthData = function (authData) { + const providers = Object.keys(authData); + const query = providers.reduce((memo, provider) => { + if (!authData[provider]) { + return memo; + } + const queryKey = `authData.${provider}.id`; + const query = {}; + query[queryKey] = authData[provider].id; + memo.push(query); + return memo; + }, []).filter(q => { + return typeof q !== 'undefined'; + }); + + let findPromise = Promise.resolve([]); + if (query.length > 0) { + findPromise = this.config.database.find(this.className, { '$or': query }, {}); + } + + return findPromise; +}; + +RestWrite.prototype.handleAuthData = function (authData) { + let results; + return this.findUsersWithAuthData(authData).then(r => { + results = r; + if (results.length > 1) { + // More than 1 user with the passed id's + throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used'); + } + + this.storage['authProvider'] = Object.keys(authData).join(','); + + if (results.length > 0) { + const userResult = results[0]; + const mutatedAuthData = {}; + Object.keys(authData).forEach(provider => { + const providerData = authData[provider]; + const userAuthData = userResult.authData[provider]; + if (!_lodash2.default.isEqual(providerData, userAuthData)) { + mutatedAuthData[provider] = providerData; + } + }); + const hasMutatedAuthData = Object.keys(mutatedAuthData).length !== 0; + let userId; + if (this.query && this.query.objectId) { + userId = this.query.objectId; + } else if (this.auth && this.auth.user && this.auth.user.id) { + userId = this.auth.user.id; + } + if (!userId || userId === userResult.objectId) { + // no user making the call + // OR the user making the call is the right one + // Login with auth data + delete results[0].password; + + // need to set the objectId first otherwise location has trailing undefined + this.data.objectId = userResult.objectId; + + if (!this.query || !this.query.objectId) { + // this a login call, no userId passed + this.response = { + response: userResult, + location: this.location() + }; + } + // If we didn't change the auth data, just keep going + if (!hasMutatedAuthData) { + return; + } + // We have authData that is updated on login + // that can happen when token are refreshed, + // We should update the token and let the user in + // We should only check the mutated keys + return this.handleAuthDataValidation(mutatedAuthData).then(() => { + // IF we have a response, we'll skip the database operation / beforeSave / afterSave etc... + // we need to set it up there. + // We are supposed to have a response only on LOGIN with authData, so we skip those + // If we're not logging in, but just updating the current user, we can safely skip that part + if (this.response) { + // Assign the new authData in the response + Object.keys(mutatedAuthData).forEach(provider => { + this.response.response.authData[provider] = mutatedAuthData[provider]; + }); + // Run the DB update directly, as 'master' + // Just update the authData part + // Then we're good for the user, early exit of sorts + return this.config.database.update(this.className, { objectId: this.data.objectId }, { authData: mutatedAuthData }, {}); + } + }); + } else if (userId) { + // Trying to update auth data but users + // are different + if (userResult.objectId !== userId) { + throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used'); + } + // No auth data was mutated, just keep going + if (!hasMutatedAuthData) { + return; + } + } + } + return this.handleAuthDataValidation(authData); + }); +}; + +// The non-third-party parts of User transformation +RestWrite.prototype.transformUser = function () { + var promise = Promise.resolve(); + + if (this.className !== '_User') { + return promise; + } + + if (!this.auth.isMaster && "emailVerified" in this.data) { + const error = `Clients aren't allowed to manually update email verification.`; + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error); + } + + // Do not cleanup session if objectId is not set + if (this.query && this.objectId()) { + // If we're updating a _User object, we need to clear out the cache for that user. Find all their + // session tokens, and remove them from the cache. + promise = new _RestQuery2.default(this.config, Auth.master(this.config), '_Session', { + user: { + __type: "Pointer", + className: "_User", + objectId: this.objectId() + } + }).execute().then(results => { + results.results.forEach(session => this.config.cacheController.user.del(session.sessionToken)); + }); + } + + return promise.then(() => { + // Transform the password + if (this.data.password === undefined) { + // ignore only if undefined. should proceed if empty ('') + return Promise.resolve(); + } + + if (this.query) { + this.storage['clearSessions'] = true; + // Generate a new session only if the user requested + if (!this.auth.isMaster) { + this.storage['generateNewSession'] = true; + } + } + + return this._validatePasswordPolicy().then(() => { + return passwordCrypto.hash(this.data.password).then(hashedPassword => { + this.data._hashed_password = hashedPassword; + delete this.data.password; + }); + }); + }).then(() => { + return this._validateUserName(); + }).then(() => { + return this._validateEmail(); + }); +}; + +RestWrite.prototype._validateUserName = function () { + // Check for username uniqueness + if (!this.data.username) { + if (!this.query) { + this.data.username = cryptoUtils.randomString(25); + this.responseShouldHaveUsername = true; + } + return Promise.resolve(); + } + // We need to a find to check for duplicate username in case they are missing the unique index on usernames + // TODO: Check if there is a unique index, and if so, skip this query. + return this.config.database.find(this.className, { username: this.data.username, objectId: { '$ne': this.objectId() } }, { limit: 1 }).then(results => { + if (results.length > 0) { + throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.'); + } + return; + }); +}; + +RestWrite.prototype._validateEmail = function () { + if (!this.data.email || this.data.email.__op === 'Delete') { + return Promise.resolve(); + } + // Validate basic email address format + if (!this.data.email.match(/^.+@.+$/)) { + return Promise.reject(new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'Email address format is invalid.')); + } + // Same problem for email as above for username + return this.config.database.find(this.className, { email: this.data.email, objectId: { '$ne': this.objectId() } }, { limit: 1 }).then(results => { + if (results.length > 0) { + throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.'); + } + if (!this.data.authData || !Object.keys(this.data.authData).length || Object.keys(this.data.authData).length === 1 && Object.keys(this.data.authData)[0] === 'anonymous') { + // We updated the email, send a new validation + this.storage['sendVerificationEmail'] = true; + this.config.userController.setEmailVerifyToken(this.data); + } + }); +}; + +RestWrite.prototype._validatePasswordPolicy = function () { + if (!this.config.passwordPolicy) return Promise.resolve(); + return this._validatePasswordRequirements().then(() => { + return this._validatePasswordHistory(); + }); +}; + +RestWrite.prototype._validatePasswordRequirements = function () { + // check if the password conforms to the defined password policy if configured + const policyError = 'Password does not meet the Password Policy requirements.'; + + // check whether the password meets the password strength requirements + if (this.config.passwordPolicy.patternValidator && !this.config.passwordPolicy.patternValidator(this.data.password) || this.config.passwordPolicy.validatorCallback && !this.config.passwordPolicy.validatorCallback(this.data.password)) { + return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError)); + } + + // check whether password contain username + if (this.config.passwordPolicy.doNotAllowUsername === true) { + if (this.data.username) { + // username is not passed during password reset + if (this.data.password.indexOf(this.data.username) >= 0) return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError)); + } else { + // retrieve the User object using objectId during password reset + return this.config.database.find('_User', { objectId: this.objectId() }).then(results => { + if (results.length != 1) { + throw undefined; + } + if (this.data.password.indexOf(results[0].username) >= 0) return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError)); + return Promise.resolve(); + }); + } + } + return Promise.resolve(); +}; + +RestWrite.prototype._validatePasswordHistory = function () { + // check whether password is repeating from specified history + if (this.query && this.config.passwordPolicy.maxPasswordHistory) { + return this.config.database.find('_User', { objectId: this.objectId() }, { keys: ["_password_history", "_hashed_password"] }).then(results => { + if (results.length != 1) { + throw undefined; + } + const user = results[0]; + let oldPasswords = []; + if (user._password_history) oldPasswords = _lodash2.default.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory - 1); + oldPasswords.push(user.password); + const newPassword = this.data.password; + // compare the new password hash with all old password hashes + const promises = oldPasswords.map(function (hash) { + return passwordCrypto.compare(newPassword, hash).then(result => { + if (result) // reject if there is a match + return Promise.reject("REPEAT_PASSWORD"); + return Promise.resolve(); + }); + }); + // wait for all comparisons to complete + return Promise.all(promises).then(() => { + return Promise.resolve(); + }).catch(err => { + if (err === "REPEAT_PASSWORD") // a match was found + return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, `New password should not be the same as last ${this.config.passwordPolicy.maxPasswordHistory} passwords.`)); + throw err; + }); + }); + } + return Promise.resolve(); +}; + +RestWrite.prototype.createSessionTokenIfNeeded = function () { + if (this.className !== '_User') { + return; + } + if (this.query) { + return; + } + if (!this.storage['authProvider'] // signup call, with + && this.config.preventLoginWithUnverifiedEmail // no login without verification + && this.config.verifyUserEmails) { + // verification is on + return; // do not create the session token in that case! + } + return this.createSessionToken(); +}; + +RestWrite.prototype.createSessionToken = function () { + // cloud installationId from Cloud Code, + // never create session tokens from there. + if (this.auth.installationId && this.auth.installationId === 'cloud') { + return; + } + var token = 'r:' + cryptoUtils.newToken(); + + var expiresAt = this.config.generateSessionExpiresAt(); + var sessionData = { + sessionToken: token, + user: { + __type: 'Pointer', + className: '_User', + objectId: this.objectId() + }, + createdWith: { + 'action': this.storage['authProvider'] ? 'login' : 'signup', + 'authProvider': this.storage['authProvider'] || 'password' + }, + restricted: false, + installationId: this.auth.installationId, + expiresAt: Parse._encode(expiresAt) + }; + if (this.response && this.response.response) { + this.response.response.sessionToken = token; + } + + return new RestWrite(this.config, Auth.master(this.config), '_Session', null, sessionData).execute(); +}; + +RestWrite.prototype.destroyDuplicatedSessions = function () { + // Only for _Session, and at creation time + if (this.className != '_Session' || this.query) { + return; + } + // Destroy the sessions in 'Background' + const { + user, + installationId, + sessionToken + } = this.data; + if (!user || !installationId) { + return; + } + if (!user.objectId) { + return; + } + this.config.database.destroy('_Session', { + user, + installationId, + sessionToken: { '$ne': sessionToken } + }); +}; + +// Handles any followup logic +RestWrite.prototype.handleFollowup = function () { + if (this.storage && this.storage['clearSessions'] && this.config.revokeSessionOnPasswordReset) { + var sessionQuery = { + user: { + __type: 'Pointer', + className: '_User', + objectId: this.objectId() + } + }; + delete this.storage['clearSessions']; + return this.config.database.destroy('_Session', sessionQuery).then(this.handleFollowup.bind(this)); + } + + if (this.storage && this.storage['generateNewSession']) { + delete this.storage['generateNewSession']; + return this.createSessionToken().then(this.handleFollowup.bind(this)); + } + + if (this.storage && this.storage['sendVerificationEmail']) { + delete this.storage['sendVerificationEmail']; + // Fire and forget! + this.config.userController.sendVerificationEmail(this.data); + return this.handleFollowup.bind(this); + } +}; + +// Handles the _Session class specialness. +// Does nothing if this isn't an _Session object. +RestWrite.prototype.handleSession = function () { + if (this.response || this.className !== '_Session') { + return; + } + + if (!this.auth.user && !this.auth.isMaster) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Session token required.'); + } + + // TODO: Verify proper error to throw + if (this.data.ACL) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'Cannot set ' + 'ACL on a Session.'); + } + + if (this.query) { + if (this.data.user && !this.auth.isMaster && this.data.user.objectId != this.auth.user.id) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME); + } else if (this.data.installationId) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME); + } else if (this.data.sessionToken) { + throw new Parse.Error(Parse.Error.INVALID_KEY_NAME); + } + } + + if (!this.query && !this.auth.isMaster) { + var token = 'r:' + cryptoUtils.newToken(); + var expiresAt = this.config.generateSessionExpiresAt(); + var sessionData = { + sessionToken: token, + user: { + __type: 'Pointer', + className: '_User', + objectId: this.auth.user.id + }, + createdWith: { + 'action': 'create' + }, + restricted: true, + expiresAt: Parse._encode(expiresAt) + }; + for (var key in this.data) { + if (key === 'objectId' || key === 'user') { + continue; + } + sessionData[key] = this.data[key]; + } + var create = new RestWrite(this.config, Auth.master(this.config), '_Session', null, sessionData); + return create.execute().then(results => { + if (!results.response) { + throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Error creating session.'); + } + sessionData['objectId'] = results.response['objectId']; + this.response = { + status: 201, + location: results.location, + response: sessionData + }; + }); + } +}; + +// Handles the _Installation class specialness. +// Does nothing if this isn't an installation object. +// If an installation is found, this can mutate this.query and turn a create +// into an update. +// Returns a promise for when we're done if it can't finish this tick. +RestWrite.prototype.handleInstallation = function () { + if (this.response || this.className !== '_Installation') { + return; + } + + if (!this.query && !this.data.deviceToken && !this.data.installationId && !this.auth.installationId) { + throw new Parse.Error(135, 'at least one ID field (deviceToken, installationId) ' + 'must be specified in this operation'); + } + + // If the device token is 64 characters long, we assume it is for iOS + // and lowercase it. + if (this.data.deviceToken && this.data.deviceToken.length == 64) { + this.data.deviceToken = this.data.deviceToken.toLowerCase(); + } + + // We lowercase the installationId if present + if (this.data.installationId) { + this.data.installationId = this.data.installationId.toLowerCase(); + } + + let installationId = this.data.installationId; + + // If data.installationId is not set and we're not master, we can lookup in auth + if (!installationId && !this.auth.isMaster) { + installationId = this.auth.installationId; + } + + if (installationId) { + installationId = installationId.toLowerCase(); + } + + // Updating _Installation but not updating anything critical + if (this.query && !this.data.deviceToken && !installationId && !this.data.deviceType) { + return; + } + + var promise = Promise.resolve(); + + var idMatch; // Will be a match on either objectId or installationId + var objectIdMatch; + var installationIdMatch; + var deviceTokenMatches = []; + + // Instead of issuing 3 reads, let's do it with one OR. + const orQueries = []; + if (this.query && this.query.objectId) { + orQueries.push({ + objectId: this.query.objectId + }); + } + if (installationId) { + orQueries.push({ + 'installationId': installationId + }); + } + if (this.data.deviceToken) { + orQueries.push({ 'deviceToken': this.data.deviceToken }); + } + + if (orQueries.length == 0) { + return; + } + + promise = promise.then(() => { + return this.config.database.find('_Installation', { + '$or': orQueries + }, {}); + }).then(results => { + results.forEach(result => { + if (this.query && this.query.objectId && result.objectId == this.query.objectId) { + objectIdMatch = result; + } + if (result.installationId == installationId) { + installationIdMatch = result; + } + if (result.deviceToken == this.data.deviceToken) { + deviceTokenMatches.push(result); + } + }); + + // Sanity checks when running a query + if (this.query && this.query.objectId) { + if (!objectIdMatch) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found for update.'); + } + if (this.data.installationId && objectIdMatch.installationId && this.data.installationId !== objectIdMatch.installationId) { + throw new Parse.Error(136, 'installationId may not be changed in this ' + 'operation'); + } + if (this.data.deviceToken && objectIdMatch.deviceToken && this.data.deviceToken !== objectIdMatch.deviceToken && !this.data.installationId && !objectIdMatch.installationId) { + throw new Parse.Error(136, 'deviceToken may not be changed in this ' + 'operation'); + } + if (this.data.deviceType && this.data.deviceType && this.data.deviceType !== objectIdMatch.deviceType) { + throw new Parse.Error(136, 'deviceType may not be changed in this ' + 'operation'); + } + } + + if (this.query && this.query.objectId && objectIdMatch) { + idMatch = objectIdMatch; + } + + if (installationId && installationIdMatch) { + idMatch = installationIdMatch; + } + // need to specify deviceType only if it's new + if (!this.query && !this.data.deviceType && !idMatch) { + throw new Parse.Error(135, 'deviceType must be specified in this operation'); + } + }).then(() => { + if (!idMatch) { + if (!deviceTokenMatches.length) { + return; + } else if (deviceTokenMatches.length == 1 && (!deviceTokenMatches[0]['installationId'] || !installationId)) { + // Single match on device token but none on installationId, and either + // the passed object or the match is missing an installationId, so we + // can just return the match. + return deviceTokenMatches[0]['objectId']; + } else if (!this.data.installationId) { + throw new Parse.Error(132, 'Must specify installationId when deviceToken ' + 'matches multiple Installation objects'); + } else { + // Multiple device token matches and we specified an installation ID, + // or a single match where both the passed and matching objects have + // an installation ID. Try cleaning out old installations that match + // the deviceToken, and return nil to signal that a new object should + // be created. + var delQuery = { + 'deviceToken': this.data.deviceToken, + 'installationId': { + '$ne': installationId + } + }; + if (this.data.appIdentifier) { + delQuery['appIdentifier'] = this.data.appIdentifier; + } + this.config.database.destroy('_Installation', delQuery).catch(err => { + if (err.code == Parse.Error.OBJECT_NOT_FOUND) { + // no deletions were made. Can be ignored. + return; + } + // rethrow the error + throw err; + }); + return; + } + } else { + if (deviceTokenMatches.length == 1 && !deviceTokenMatches[0]['installationId']) { + // Exactly one device token match and it doesn't have an installation + // ID. This is the one case where we want to merge with the existing + // object. + const delQuery = { objectId: idMatch.objectId }; + return this.config.database.destroy('_Installation', delQuery).then(() => { + return deviceTokenMatches[0]['objectId']; + }).catch(err => { + if (err.code == Parse.Error.OBJECT_NOT_FOUND) { + // no deletions were made. Can be ignored + return; + } + // rethrow the error + throw err; + }); + } else { + if (this.data.deviceToken && idMatch.deviceToken != this.data.deviceToken) { + // We're setting the device token on an existing installation, so + // we should try cleaning out old installations that match this + // device token. + const delQuery = { + 'deviceToken': this.data.deviceToken + }; + // We have a unique install Id, use that to preserve + // the interesting installation + if (this.data.installationId) { + delQuery['installationId'] = { + '$ne': this.data.installationId + }; + } else if (idMatch.objectId && this.data.objectId && idMatch.objectId == this.data.objectId) { + // we passed an objectId, preserve that instalation + delQuery['objectId'] = { + '$ne': idMatch.objectId + }; + } else { + // What to do here? can't really clean up everything... + return idMatch.objectId; + } + if (this.data.appIdentifier) { + delQuery['appIdentifier'] = this.data.appIdentifier; + } + this.config.database.destroy('_Installation', delQuery).catch(err => { + if (err.code == Parse.Error.OBJECT_NOT_FOUND) { + // no deletions were made. Can be ignored. + return; + } + // rethrow the error + throw err; + }); + } + // In non-merge scenarios, just return the installation match id + return idMatch.objectId; + } + } + }).then(objId => { + if (objId) { + this.query = { objectId: objId }; + delete this.data.objectId; + delete this.data.createdAt; + } + // TODO: Validate ops (add/remove on channels, $inc on badge, etc.) + }); + return promise; +}; + +// If we short-circuted the object response - then we need to make sure we expand all the files, +// since this might not have a query, meaning it won't return the full result back. +// TODO: (nlutsenko) This should die when we move to per-class based controllers on _Session/_User +RestWrite.prototype.expandFilesForExistingObjects = function () { + // Check whether we have a short-circuited response - only then run expansion. + if (this.response && this.response.response) { + this.config.filesController.expandFilesInObject(this.config, this.response.response); + } +}; + +RestWrite.prototype.runDatabaseOperation = function () { + if (this.response) { + return; + } + + if (this.className === '_Role') { + this.config.cacheController.role.clear(); + } + + if (this.className === '_User' && this.query && !this.auth.couldUpdateUserId(this.query.objectId)) { + throw new Parse.Error(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`); + } + + if (this.className === '_Product' && this.data.download) { + this.data.downloadName = this.data.download.name; + } + + // TODO: Add better detection for ACL, ensuring a user can't be locked from + // their own user record. + if (this.data.ACL && this.data.ACL['*unresolved']) { + throw new Parse.Error(Parse.Error.INVALID_ACL, 'Invalid ACL.'); + } + + if (this.query) { + // Force the user to not lockout + // Matched with parse.com + if (this.className === '_User' && this.data.ACL) { + this.data.ACL[this.query.objectId] = { read: true, write: true }; + } + // update password timestamp if user password is being changed + if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) { + this.data._password_changed_at = Parse._encode(new Date()); + } + // Ignore createdAt when update + delete this.data.createdAt; + + let defer = Promise.resolve(); + // if password history is enabled then save the current password to history + if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordHistory) { + defer = this.config.database.find('_User', { objectId: this.objectId() }, { keys: ["_password_history", "_hashed_password"] }).then(results => { + if (results.length != 1) { + throw undefined; + } + const user = results[0]; + let oldPasswords = []; + if (user._password_history) { + oldPasswords = _lodash2.default.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory); + } + //n-1 passwords go into history including last password + while (oldPasswords.length > this.config.passwordPolicy.maxPasswordHistory - 2) { + oldPasswords.shift(); + } + oldPasswords.push(user.password); + this.data._password_history = oldPasswords; + }); + } + + return defer.then(() => { + // Run an update + return this.config.database.update(this.className, this.query, this.data, this.runOptions).then(response => { + response.updatedAt = this.updatedAt; + this._updateResponseWithData(response, this.data); + this.response = { response }; + }); + }); + } else { + // Set the default ACL and password timestamp for the new _User + if (this.className === '_User') { + var ACL = this.data.ACL; + // default public r/w ACL + if (!ACL) { + ACL = {}; + ACL['*'] = { read: true, write: false }; + } + // make sure the user is not locked down + ACL[this.data.objectId] = { read: true, write: true }; + this.data.ACL = ACL; + // password timestamp to be used when password expiry policy is enforced + if (this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) { + this.data._password_changed_at = Parse._encode(new Date()); + } + } + + // Run a create + return this.config.database.create(this.className, this.data, this.runOptions).catch(error => { + if (this.className !== '_User' || error.code !== Parse.Error.DUPLICATE_VALUE) { + throw error; + } + + // Quick check, if we were able to infer the duplicated field name + if (error && error.userInfo && error.userInfo.duplicated_field === 'username') { + throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.'); + } + + if (error && error.userInfo && error.userInfo.duplicated_field === 'email') { + throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.'); + } + + // If this was a failed user creation due to username or email already taken, we need to + // check whether it was username or email and return the appropriate error. + // Fallback to the original method + // TODO: See if we can later do this without additional queries by using named indexes. + return this.config.database.find(this.className, { username: this.data.username, objectId: { '$ne': this.objectId() } }, { limit: 1 }).then(results => { + if (results.length > 0) { + throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.'); + } + return this.config.database.find(this.className, { email: this.data.email, objectId: { '$ne': this.objectId() } }, { limit: 1 }); + }).then(results => { + if (results.length > 0) { + throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.'); + } + throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided'); + }); + }).then(response => { + response.objectId = this.data.objectId; + response.createdAt = this.data.createdAt; + + if (this.responseShouldHaveUsername) { + response.username = this.data.username; + } + this._updateResponseWithData(response, this.data); + this.response = { + status: 201, + response, + location: this.location() + }; + }); + } +}; + +// Returns nothing - doesn't wait for the trigger. +RestWrite.prototype.runAfterTrigger = function () { + if (!this.response || !this.response.response) { + return; + } + + // Avoid doing any setup for triggers if there is no 'afterSave' trigger for this class. + const hasAfterSaveHook = triggers.triggerExists(this.className, triggers.Types.afterSave, this.config.applicationId); + const hasLiveQuery = this.config.liveQueryController.hasLiveQuery(this.className); + if (!hasAfterSaveHook && !hasLiveQuery) { + return Promise.resolve(); + } + + var extraData = { className: this.className }; + if (this.query && this.query.objectId) { + extraData.objectId = this.query.objectId; + } + + // Build the original object, we only do this for a update write. + let originalObject; + if (this.query && this.query.objectId) { + originalObject = triggers.inflate(extraData, this.originalData); + } + + // Build the inflated object, different from beforeSave, originalData is not empty + // since developers can change data in the beforeSave. + const updatedObject = this.buildUpdatedObject(extraData); + updatedObject._handleSaveResponse(this.response.response, this.response.status || 200); + + // Notifiy LiveQueryServer if possible + this.config.liveQueryController.onAfterSave(updatedObject.className, updatedObject, originalObject); + + // Run afterSave trigger + return triggers.maybeRunTrigger(triggers.Types.afterSave, this.auth, updatedObject, originalObject, this.config).catch(function (err) { + _logger2.default.warn('afterSave caught an error', err); + }); +}; + +// A helper to figure out what location this operation happens at. +RestWrite.prototype.location = function () { + var middle = this.className === '_User' ? '/users/' : '/classes/' + this.className + '/'; + return this.config.mount + middle + this.data.objectId; +}; + +// A helper to get the object id for this operation. +// Because it could be either on the query or on the data +RestWrite.prototype.objectId = function () { + return this.data.objectId || this.query.objectId; +}; + +// Returns a copy of the data and delete bad keys (_auth_data, _hashed_password...) +RestWrite.prototype.sanitizedData = function () { + const data = Object.keys(this.data).reduce((data, key) => { + // Regexp comes from Parse.Object.prototype.validate + if (!/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) { + delete data[key]; + } + return data; + }, deepcopy(this.data)); + return Parse._decode(undefined, data); +}; + +// Returns an updated copy of the object +RestWrite.prototype.buildUpdatedObject = function (extraData) { + const updatedObject = triggers.inflate(extraData, this.originalData); + Object.keys(this.data).reduce(function (data, key) { + if (key.indexOf(".") > 0) { + // subdocument key with dot notation ('x.y':v => 'x':{'y':v}) + const splittedKey = key.split("."); + const parentProp = splittedKey[0]; + let parentVal = updatedObject.get(parentProp); + if (typeof parentVal !== 'object') { + parentVal = {}; + } + parentVal[splittedKey[1]] = data[key]; + updatedObject.set(parentProp, parentVal); + delete data[key]; + } + return data; + }, deepcopy(this.data)); + + updatedObject.set(this.sanitizedData()); + return updatedObject; +}; + +RestWrite.prototype.cleanUserAuthData = function () { + if (this.response && this.response.response && this.className === '_User') { + const user = this.response.response; + if (user.authData) { + Object.keys(user.authData).forEach(provider => { + if (user.authData[provider] === null) { + delete user.authData[provider]; + } + }); + if (Object.keys(user.authData).length == 0) { + delete user.authData; + } + } + } +}; + +RestWrite.prototype._updateResponseWithData = function (response, data) { + if (_lodash2.default.isEmpty(this.storage.fieldsChangedByTrigger)) { + return response; + } + const clientSupportsDelete = ClientSDK.supportsForwardDelete(this.clientSDK); + this.storage.fieldsChangedByTrigger.forEach(fieldName => { + const dataValue = data[fieldName]; + + if (!response.hasOwnProperty(fieldName)) { + response[fieldName] = dataValue; + } + + // Strips operations from responses + if (response[fieldName] && response[fieldName].__op) { + delete response[fieldName]; + if (clientSupportsDelete && dataValue.__op == 'Delete') { + response[fieldName] = dataValue; + } + } + }); + return response; +}; + +exports.default = RestWrite; + +module.exports = RestWrite; \ No newline at end of file diff --git a/lib/Routers/AggregateRouter.js b/lib/Routers/AggregateRouter.js new file mode 100644 index 0000000000..2a0519915e --- /dev/null +++ b/lib/Routers/AggregateRouter.js @@ -0,0 +1,82 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AggregateRouter = undefined; + +var _ClassesRouter = require('./ClassesRouter'); + +var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _UsersRouter = require('./UsersRouter'); + +var _UsersRouter2 = _interopRequireDefault(_UsersRouter); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const ALLOWED_KEYS = ['where', 'distinct', 'project', 'match', 'redact', 'limit', 'skip', 'unwind', 'group', 'sample', 'sort', 'geoNear', 'lookup', 'out', 'indexStats', 'facet', 'bucket', 'bucketAuto', 'sortByCount', 'addFields', 'replaceRoot', 'count', 'graphLookup']; + +class AggregateRouter extends _ClassesRouter2.default { + + handleFind(req) { + const body = Object.assign(req.body, _ClassesRouter2.default.JSONFromQuery(req.query)); + const options = {}; + const pipeline = []; + + for (const key in body) { + if (ALLOWED_KEYS.indexOf(key) === -1) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: ${key}`); + } + if (key === 'group') { + if (body[key].hasOwnProperty('_id')) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: group. Please use objectId instead of _id`); + } + if (!body[key].hasOwnProperty('objectId')) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: group. objectId is required`); + } + body[key]._id = body[key].objectId; + delete body[key].objectId; + } + pipeline.push({ [`$${key}`]: body[key] }); + } + if (body.distinct) { + options.distinct = String(body.distinct); + } + options.pipeline = pipeline; + if (typeof body.where === 'string') { + body.where = JSON.parse(body.where); + } + return _rest2.default.find(req.config, req.auth, this.className(req), body.where, options, req.info.clientSDK).then(response => { + for (const result of response.results) { + if (typeof result === 'object') { + _UsersRouter2.default.removeHiddenProperties(result); + } + } + return { response }; + }); + } + + mountRoutes() { + this.route('GET', '/aggregate/:className', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handleFind(req); + }); + } +} + +exports.AggregateRouter = AggregateRouter; +exports.default = AggregateRouter; \ No newline at end of file diff --git a/lib/Routers/AnalyticsRouter.js b/lib/Routers/AnalyticsRouter.js new file mode 100644 index 0000000000..4cd6885171 --- /dev/null +++ b/lib/Routers/AnalyticsRouter.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AnalyticsRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function appOpened(req) { + const analyticsController = req.config.analyticsController; + return analyticsController.appOpened(req); +} // AnalyticsRouter.js + + +function trackEvent(req) { + const analyticsController = req.config.analyticsController; + return analyticsController.trackEvent(req); +} + +class AnalyticsRouter extends _PromiseRouter2.default { + mountRoutes() { + this.route('POST', '/events/AppOpened', appOpened); + this.route('POST', '/events/:eventName', trackEvent); + } +} +exports.AnalyticsRouter = AnalyticsRouter; \ No newline at end of file diff --git a/lib/Routers/AudiencesRouter.js b/lib/Routers/AudiencesRouter.js new file mode 100644 index 0000000000..ce31014ea5 --- /dev/null +++ b/lib/Routers/AudiencesRouter.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AudiencesRouter = undefined; + +var _ClassesRouter = require('./ClassesRouter'); + +var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class AudiencesRouter extends _ClassesRouter2.default { + + className() { + return '_Audience'; + } + + handleFind(req) { + const body = Object.assign(req.body, _ClassesRouter2.default.JSONFromQuery(req.query)); + const options = _ClassesRouter2.default.optionsFromBody(body); + + return _rest2.default.find(req.config, req.auth, '_Audience', body.where, options, req.info.clientSDK).then(response => { + + response.results.forEach(item => { + item.query = JSON.parse(item.query); + }); + + return { response: response }; + }); + } + + handleGet(req) { + return super.handleGet(req).then(data => { + data.response.query = JSON.parse(data.response.query); + + return data; + }); + } + + mountRoutes() { + this.route('GET', '/push_audiences', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handleFind(req); + }); + this.route('GET', '/push_audiences/:objectId', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handleGet(req); + }); + this.route('POST', '/push_audiences', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handleCreate(req); + }); + this.route('PUT', '/push_audiences/:objectId', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handleUpdate(req); + }); + this.route('DELETE', '/push_audiences/:objectId', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handleDelete(req); + }); + } +} + +exports.AudiencesRouter = AudiencesRouter; +exports.default = AudiencesRouter; \ No newline at end of file diff --git a/lib/Routers/ClassesRouter.js b/lib/Routers/ClassesRouter.js new file mode 100644 index 0000000000..d038344e8b --- /dev/null +++ b/lib/Routers/ClassesRouter.js @@ -0,0 +1,169 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ClassesRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const ALLOWED_GET_QUERY_KEYS = ['keys', 'include']; + +class ClassesRouter extends _PromiseRouter2.default { + + className(req) { + return req.params.className; + } + + handleFind(req) { + const body = Object.assign(req.body, ClassesRouter.JSONFromQuery(req.query)); + const options = ClassesRouter.optionsFromBody(body); + if (req.config.maxLimit && body.limit > req.config.maxLimit) { + // Silently replace the limit on the query with the max configured + options.limit = Number(req.config.maxLimit); + } + if (body.redirectClassNameForKey) { + options.redirectClassNameForKey = String(body.redirectClassNameForKey); + } + if (typeof body.where === 'string') { + body.where = JSON.parse(body.where); + } + return _rest2.default.find(req.config, req.auth, this.className(req), body.where, options, req.info.clientSDK).then(response => { + return { response: response }; + }); + } + + // Returns a promise for a {response} object. + handleGet(req) { + const body = Object.assign(req.body, ClassesRouter.JSONFromQuery(req.query)); + const options = {}; + + for (const key of Object.keys(body)) { + if (ALLOWED_GET_QUERY_KEYS.indexOf(key) === -1) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, 'Improper encode of parameter'); + } + } + + if (typeof body.keys == 'string') { + options.keys = body.keys; + } + if (body.include) { + options.include = String(body.include); + } + + return _rest2.default.get(req.config, req.auth, this.className(req), req.params.objectId, options, req.info.clientSDK).then(response => { + if (!response.results || response.results.length == 0) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Object not found.'); + } + + if (this.className(req) === "_User") { + + delete response.results[0].sessionToken; + + const user = response.results[0]; + + if (req.auth.user && user.objectId == req.auth.user.id) { + // Force the session token + response.results[0].sessionToken = req.info.sessionToken; + } + } + return { response: response.results[0] }; + }); + } + + handleCreate(req) { + return _rest2.default.create(req.config, req.auth, this.className(req), req.body, req.info.clientSDK); + } + + handleUpdate(req) { + const where = { objectId: req.params.objectId }; + return _rest2.default.update(req.config, req.auth, this.className(req), where, req.body, req.info.clientSDK); + } + + handleDelete(req) { + return _rest2.default.del(req.config, req.auth, this.className(req), req.params.objectId, req.info.clientSDK).then(() => { + return { response: {} }; + }); + } + + static JSONFromQuery(query) { + const json = {}; + for (const [key, value] of _lodash2.default.entries(query)) { + try { + json[key] = JSON.parse(value); + } catch (e) { + json[key] = value; + } + } + return json; + } + + static optionsFromBody(body) { + const allowConstraints = ['skip', 'limit', 'order', 'count', 'keys', 'include', 'redirectClassNameForKey', 'where']; + + for (const key of Object.keys(body)) { + if (allowConstraints.indexOf(key) === -1) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: ${key}`); + } + } + const options = {}; + if (body.skip) { + options.skip = Number(body.skip); + } + if (body.limit || body.limit === 0) { + options.limit = Number(body.limit); + } else { + options.limit = Number(100); + } + if (body.order) { + options.order = String(body.order); + } + if (body.count) { + options.count = true; + } + if (typeof body.keys == 'string') { + options.keys = body.keys; + } + if (body.include) { + options.include = String(body.include); + } + return options; + } + + mountRoutes() { + this.route('GET', '/classes/:className', req => { + return this.handleFind(req); + }); + this.route('GET', '/classes/:className/:objectId', req => { + return this.handleGet(req); + }); + this.route('POST', '/classes/:className', req => { + return this.handleCreate(req); + }); + this.route('PUT', '/classes/:className/:objectId', req => { + return this.handleUpdate(req); + }); + this.route('DELETE', '/classes/:className/:objectId', req => { + return this.handleDelete(req); + }); + } +} + +exports.ClassesRouter = ClassesRouter; +exports.default = ClassesRouter; \ No newline at end of file diff --git a/lib/Routers/CloudCodeRouter.js b/lib/Routers/CloudCodeRouter.js new file mode 100644 index 0000000000..69ff4066e4 --- /dev/null +++ b/lib/Routers/CloudCodeRouter.js @@ -0,0 +1,95 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.CloudCodeRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const triggers = require('../triggers'); +const middleware = require('../middlewares'); + +function formatJobSchedule(job_schedule) { + if (typeof job_schedule.startAfter === 'undefined') { + job_schedule.startAfter = new Date().toISOString(); + } + return job_schedule; +} + +function validateJobSchedule(config, job_schedule) { + const jobs = triggers.getJobs(config.applicationId) || {}; + if (job_schedule.jobName && !jobs[job_schedule.jobName]) { + throw new _node2.default.Error(_node2.default.Error.INTERNAL_SERVER_ERROR, 'Cannot Schedule a job that is not deployed'); + } +} + +class CloudCodeRouter extends _PromiseRouter2.default { + mountRoutes() { + this.route('GET', '/cloud_code/jobs', middleware.promiseEnforceMasterKeyAccess, CloudCodeRouter.getJobs); + this.route('GET', '/cloud_code/jobs/data', middleware.promiseEnforceMasterKeyAccess, CloudCodeRouter.getJobsData); + this.route('POST', '/cloud_code/jobs', middleware.promiseEnforceMasterKeyAccess, CloudCodeRouter.createJob); + this.route('PUT', '/cloud_code/jobs/:objectId', middleware.promiseEnforceMasterKeyAccess, CloudCodeRouter.editJob); + this.route('DELETE', '/cloud_code/jobs/:objectId', middleware.promiseEnforceMasterKeyAccess, CloudCodeRouter.deleteJob); + } + + static getJobs(req) { + return _rest2.default.find(req.config, req.auth, '_JobSchedule', {}, {}).then(scheduledJobs => { + return { + response: scheduledJobs.results + }; + }); + } + + static getJobsData(req) { + const config = req.config; + const jobs = triggers.getJobs(config.applicationId) || {}; + return _rest2.default.find(req.config, req.auth, '_JobSchedule', {}, {}).then(scheduledJobs => { + return { + response: { + in_use: scheduledJobs.results.map(job => job.jobName), + jobs: Object.keys(jobs) + } + }; + }); + } + + static createJob(req) { + const { job_schedule } = req.body; + validateJobSchedule(req.config, job_schedule); + return _rest2.default.create(req.config, req.auth, '_JobSchedule', formatJobSchedule(job_schedule), req.client); + } + + static editJob(req) { + const { objectId } = req.params; + const { job_schedule } = req.body; + validateJobSchedule(req.config, job_schedule); + return _rest2.default.update(req.config, req.auth, '_JobSchedule', { objectId }, formatJobSchedule(job_schedule)).then(response => { + return { + response + }; + }); + } + + static deleteJob(req) { + const { objectId } = req.params; + return _rest2.default.del(req.config, req.auth, '_JobSchedule', objectId).then(response => { + return { + response + }; + }); + } +} +exports.CloudCodeRouter = CloudCodeRouter; \ No newline at end of file diff --git a/lib/Routers/ExportRouter.js b/lib/Routers/ExportRouter.js new file mode 100644 index 0000000000..0e834ae1e4 --- /dev/null +++ b/lib/Routers/ExportRouter.js @@ -0,0 +1,212 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ExportRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _AdapterLoader = require('../Adapters/AdapterLoader'); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _archiver = require('archiver'); + +var _archiver2 = _interopRequireDefault(_archiver); + +var _tmp = require('tmp'); + +var _tmp2 = _interopRequireDefault(_tmp); + +var _fs = require('fs'); + +var _fs2 = _interopRequireDefault(_fs); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const DefaultExportExportProgressCollectionName = "_ExportProgress"; +const relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } }; + +class ExportRouter extends _PromiseRouter2.default { + + exportClassPage(req, name, jsonFileStream, where, skip, limit) { + + const databaseController = req.config.database; + + const options = { + skip, + limit + }; + + const findPromise = name.indexOf('_Join') === 0 ? databaseController.adapter.find(name, relationSchema, where, options) : _rest2.default.find(req.config, req.auth, name, where, options); + + return findPromise.then(data => { + if (Array.isArray(data)) { + data = { results: data }; + } + + if (skip && data.results.length) { + jsonFileStream.write(',\n'); + } + + jsonFileStream.write(JSON.stringify(data.results, null, 2).substr(1).slice(0, -1)); + }); + } + + exportClass(req, data) { + + const databaseController = req.config.database; + const tmpJsonFile = _tmp2.default.fileSync(); + const jsonFileStream = _fs2.default.createWriteStream(tmpJsonFile.name); + + jsonFileStream.write('{\n"results" : [\n'); + + const findPromise = data.name.indexOf('_Join') === 0 ? databaseController.adapter.count(data.name, relationSchema, data.where) : _rest2.default.find(req.config, req.auth, data.name, data.where, { count: true, limit: 0 }); + + return findPromise.then(result => { + + if (Number.isInteger(result)) { + result = { count: result }; + } + + let i = 0; + const pageLimit = 1000; + let promise = Promise.resolve(); + + for (i = 0; i < result.count; i += pageLimit) { + + const skip = i; + promise = promise.then(() => { + return this.exportClassPage(req, data.name, jsonFileStream, data.where, skip, pageLimit); + }); + } + + return promise; + }).then(() => { + + jsonFileStream.end(']\n}'); + + return new Promise(resolve => { + + jsonFileStream.on('close', () => { + tmpJsonFile._name = `${data.name.replace(/:/g, '꞉')}.json`; + + resolve(tmpJsonFile); + }); + }); + }); + } + + handleExportProgress(req) { + + const databaseController = req.config.database; + + const query = { + masterKey: req.info.masterKey, + applicationId: req.info.appId + }; + + return databaseController.find(DefaultExportExportProgressCollectionName, query).then(response => { + return { response }; + }); + } + + handleExport(req) { + + const databaseController = req.config.database; + + const emailControllerAdapter = (0, _AdapterLoader.loadAdapter)(req.config.emailAdapter); + + if (!emailControllerAdapter) { + return Promise.reject(new Error('You have to setup a Mail Adapter.')); + } + + const exportProgress = { + id: req.body.name, + masterKey: req.info.masterKey, + applicationId: req.info.appId + }; + + databaseController.create(DefaultExportExportProgressCollectionName, exportProgress).then(() => { + return databaseController.loadSchema({ clearCache: true }); + }).then(schemaController => schemaController.getOneSchema(req.body.name, true)).then(schema => { + const classNames = [req.body.name]; + Object.keys(schema.fields).forEach(fieldName => { + const field = schema.fields[fieldName]; + + if (field.type === 'Relation') { + classNames.push(`_Join:${fieldName}:${req.body.name}`); + } + }); + + const promisses = classNames.map(name => { + return this.exportClass(req, { name }); + }); + + return Promise.all(promisses); + }).then(jsonFiles => { + + return new Promise(resolve => { + const tmpZipFile = _tmp2.default.fileSync(); + const tmpZipStream = _fs2.default.createWriteStream(tmpZipFile.name); + + const zip = (0, _archiver2.default)('zip'); + zip.pipe(tmpZipStream); + + jsonFiles.forEach(tmpJsonFile => { + zip.append(_fs2.default.readFileSync(tmpJsonFile.name), { name: tmpJsonFile._name }); + tmpJsonFile.removeCallback(); + }); + + zip.finalize(); + + tmpZipStream.on('close', () => { + + const buf = _fs2.default.readFileSync(tmpZipFile.name); + tmpZipFile.removeCallback(); + resolve(buf); + }); + }); + }).then(zippedFile => { + const filesController = req.config.filesController; + return filesController.createFile(req.config, req.body.name, zippedFile, 'application/zip'); + }).then(fileData => { + + return emailControllerAdapter.sendMail({ + text: `We have successfully exported your data from the class ${req.body.name}.\n + Please download from ${fileData.url}`, + link: fileData.url, + to: req.body.feedbackEmail, + subject: 'Export completed' + }); + }).catch(error => { + return emailControllerAdapter.sendMail({ + text: `We could not export your data to the class ${req.body.name}. Error: ${error}`, + to: req.body.feedbackEmail, + subject: 'Export failed' + }); + }).then(() => { + return databaseController.destroy(DefaultExportExportProgressCollectionName, exportProgress); + }); + + return Promise.resolve({ response: 'We are exporting your data. You will be notified by e-mail once it is completed.' }); + } + + mountRoutes() { + this.route('PUT', '/export_data', req => { + return this.handleExport(req); + }); + + this.route('GET', '/export_progress', req => { + return this.handleExportProgress(req); + }); + } +} + +exports.ExportRouter = ExportRouter; +exports.default = ExportRouter; \ No newline at end of file diff --git a/lib/Routers/FeaturesRouter.js b/lib/Routers/FeaturesRouter.js new file mode 100644 index 0000000000..df7fe673b4 --- /dev/null +++ b/lib/Routers/FeaturesRouter.js @@ -0,0 +1,75 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.FeaturesRouter = undefined; + +var _package = require('../../package.json'); + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class FeaturesRouter extends _PromiseRouter2.default { + mountRoutes() { + this.route('GET', '/serverInfo', middleware.promiseEnforceMasterKeyAccess, req => { + const features = { + globalConfig: { + create: true, + read: true, + update: true, + delete: true + }, + hooks: { + create: true, + read: true, + update: true, + delete: true + }, + cloudCode: { + jobs: true + }, + logs: { + level: true, + size: true, + order: true, + until: true, + from: true + }, + push: { + immediatePush: req.config.hasPushSupport, + scheduledPush: req.config.hasPushScheduledSupport, + storedPushData: req.config.hasPushSupport, + pushAudiences: true, + localization: true + }, + schemas: { + addField: true, + removeField: true, + addClass: true, + removeClass: true, + clearAllDataFromClass: true, + import: true, + exportClass: true, + editClassLevelPermissions: true, + editPointerPermissions: true + } + }; + + return { response: { + features: features, + parseServerVersion: _package.version + } }; + }); + } +} +exports.FeaturesRouter = FeaturesRouter; \ No newline at end of file diff --git a/lib/Routers/FilesRouter.js b/lib/Routers/FilesRouter.js new file mode 100644 index 0000000000..8ab5e94388 --- /dev/null +++ b/lib/Routers/FilesRouter.js @@ -0,0 +1,205 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.FilesRouter = undefined; + +var _express = require('express'); + +var _express2 = _interopRequireDefault(_express); + +var _bodyParser = require('body-parser'); + +var _bodyParser2 = _interopRequireDefault(_bodyParser); + +var _middlewares = require('../middlewares'); + +var Middlewares = _interopRequireWildcard(_middlewares); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _Config = require('../Config'); + +var _Config2 = _interopRequireDefault(_Config); + +var _mime = require('mime'); + +var _mime2 = _interopRequireDefault(_mime); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class FilesRouter { + + expressRouter({ maxUploadSize = '20Mb' } = {}) { + var router = _express2.default.Router(); + router.get('/files/:appId/:filename', this.getHandler); + + router.post('/files', function (req, res, next) { + next(new _node2.default.Error(_node2.default.Error.INVALID_FILE_NAME, 'Filename not provided.')); + }); + + router.post('/files/:filename', Middlewares.allowCrossDomain, _bodyParser2.default.raw({ type: () => { + return true; + }, limit: maxUploadSize }), // Allow uploads without Content-Type, or with any Content-Type. + Middlewares.handleParseHeaders, this.createHandler); + + router.delete('/files/:filename', Middlewares.allowCrossDomain, Middlewares.handleParseHeaders, Middlewares.enforceMasterKeyAccess, this.deleteHandler); + return router; + } + + getHandler(req, res) { + const config = _Config2.default.get(req.params.appId); + const filesController = config.filesController; + const filename = req.params.filename; + const contentType = _mime2.default.getType(filename); + if (isFileStreamable(req, filesController)) { + filesController.getFileStream(config, filename).then(stream => { + handleFileStream(stream, req, res, contentType); + }).catch(() => { + res.status(404); + res.set('Content-Type', 'text/plain'); + res.end('File not found.'); + }); + } else { + filesController.getFileData(config, filename).then(data => { + res.status(200); + res.set('Content-Type', contentType); + res.set('Content-Length', data.length); + res.end(data); + }).catch(() => { + res.status(404); + res.set('Content-Type', 'text/plain'); + res.end('File not found.'); + }); + } + } + + createHandler(req, res, next) { + if (!req.body || !req.body.length) { + next(new _node2.default.Error(_node2.default.Error.FILE_SAVE_ERROR, 'Invalid file upload.')); + return; + } + + if (req.params.filename.length > 128) { + next(new _node2.default.Error(_node2.default.Error.INVALID_FILE_NAME, 'Filename too long.')); + return; + } + + if (!req.params.filename.match(/^[_a-zA-Z0-9][a-zA-Z0-9@\.\ ~_-]*$/)) { + next(new _node2.default.Error(_node2.default.Error.INVALID_FILE_NAME, 'Filename contains invalid characters.')); + return; + } + + const filename = req.params.filename; + const contentType = req.get('Content-type'); + const config = req.config; + const filesController = config.filesController; + + filesController.createFile(config, filename, req.body, contentType).then(result => { + res.status(201); + res.set('Location', result.url); + res.json(result); + }).catch(e => { + _logger2.default.error(e.message, e); + next(new _node2.default.Error(_node2.default.Error.FILE_SAVE_ERROR, 'Could not store file.')); + }); + } + + deleteHandler(req, res, next) { + const filesController = req.config.filesController; + filesController.deleteFile(req.config, req.params.filename).then(() => { + res.status(200); + // TODO: return useful JSON here? + res.end(); + }).catch(() => { + next(new _node2.default.Error(_node2.default.Error.FILE_DELETE_ERROR, 'Could not delete file.')); + }); + } +} + +exports.FilesRouter = FilesRouter; +function isFileStreamable(req, filesController) { + return req.get('Range') && typeof filesController.adapter.getFileStream === 'function'; +} + +function getRange(req) { + const parts = req.get('Range').replace(/bytes=/, "").split("-"); + return { start: parseInt(parts[0], 10), end: parseInt(parts[1], 10) }; +} + +// handleFileStream is licenced under Creative Commons Attribution 4.0 International License (https://creativecommons.org/licenses/by/4.0/). +// Author: LEROIB at weightingformypizza (https://weightingformypizza.wordpress.com/2015/06/24/stream-html5-media-content-like-video-audio-from-mongodb-using-express-and-gridstore/). +function handleFileStream(stream, req, res, contentType) { + const buffer_size = 1024 * 1024; //1024Kb + // Range request, partiall stream the file + let { + start, end + } = getRange(req); + + const notEnded = !end && end !== 0; + const notStarted = !start && start !== 0; + // No end provided, we want all bytes + if (notEnded) { + end = stream.length - 1; + } + // No start provided, we're reading backwards + if (notStarted) { + start = stream.length - end; + end = start + end - 1; + } + + // Data exceeds the buffer_size, cap + if (end - start >= buffer_size) { + end = start + buffer_size - 1; + } + + const contentLength = end - start + 1; + + res.writeHead(206, { + 'Content-Range': 'bytes ' + start + '-' + end + '/' + stream.length, + 'Accept-Ranges': 'bytes', + 'Content-Length': contentLength, + 'Content-Type': contentType + }); + + stream.seek(start, function () { + // get gridFile stream + const gridFileStream = stream.stream(true); + let bufferAvail = 0; + let remainingBytesToWrite = contentLength; + let totalBytesWritten = 0; + // write to response + gridFileStream.on('data', function (data) { + bufferAvail += data.length; + if (bufferAvail > 0) { + // slice returns the same buffer if overflowing + // safe to call in any case + const buffer = data.slice(0, remainingBytesToWrite); + // write the buffer + res.write(buffer); + // increment total + totalBytesWritten += buffer.length; + // decrement remaining + remainingBytesToWrite -= data.length; + // decrement the avaialbe buffer + bufferAvail -= buffer.length; + } + // in case of small slices, all values will be good at that point + // we've written enough, end... + if (totalBytesWritten >= contentLength) { + stream.close(); + res.end(); + this.destroy(); + } + }); + }); +} \ No newline at end of file diff --git a/lib/Routers/FunctionsRouter.js b/lib/Routers/FunctionsRouter.js new file mode 100644 index 0000000000..ef871f47bd --- /dev/null +++ b/lib/Routers/FunctionsRouter.js @@ -0,0 +1,183 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.FunctionsRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var _StatusHandler = require('../StatusHandler'); + +var _lodash = require('lodash'); + +var _lodash2 = _interopRequireDefault(_lodash); + +var _logger = require('../logger'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// FunctionsRouter.js + +var Parse = require('parse/node').Parse, + triggers = require('../triggers'); + +function parseObject(obj) { + if (Array.isArray(obj)) { + return obj.map(item => { + return parseObject(item); + }); + } else if (obj && obj.__type == 'Date') { + return Object.assign(new Date(obj.iso), obj); + } else if (obj && obj.__type == 'File') { + return Parse.File.fromJSON(obj); + } else if (obj && typeof obj === 'object') { + return parseParams(obj); + } else { + return obj; + } +} + +function parseParams(params) { + return _lodash2.default.mapValues(params, parseObject); +} + +class FunctionsRouter extends _PromiseRouter2.default { + + mountRoutes() { + this.route('POST', '/functions/:functionName', FunctionsRouter.handleCloudFunction); + this.route('POST', '/jobs/:jobName', _middlewares.promiseEnforceMasterKeyAccess, function (req) { + return FunctionsRouter.handleCloudJob(req); + }); + this.route('POST', '/jobs', _middlewares.promiseEnforceMasterKeyAccess, function (req) { + return FunctionsRouter.handleCloudJob(req); + }); + } + + static handleCloudJob(req) { + const jobName = req.params.jobName || req.body.jobName; + const applicationId = req.config.applicationId; + const jobHandler = (0, _StatusHandler.jobStatusHandler)(req.config); + const jobFunction = triggers.getJob(jobName, applicationId); + if (!jobFunction) { + throw new Parse.Error(Parse.Error.SCRIPT_FAILED, 'Invalid job.'); + } + let params = Object.assign({}, req.body, req.query); + params = parseParams(params); + const request = { + params: params, + log: req.config.loggerController, + headers: req.config.headers, + ip: req.config.ip, + jobName + }; + const status = { + success: jobHandler.setSucceeded.bind(jobHandler), + error: jobHandler.setFailed.bind(jobHandler), + message: jobHandler.setMessage.bind(jobHandler) + }; + return jobHandler.setRunning(jobName, params).then(jobStatus => { + request.jobId = jobStatus.objectId; + // run the function async + process.nextTick(() => { + jobFunction(request, status); + }); + return { + headers: { + 'X-Parse-Job-Status-Id': jobStatus.objectId + }, + response: {} + }; + }); + } + + static createResponseObject(resolve, reject, message) { + return { + success: function (result) { + resolve({ + response: { + result: Parse._encode(result) + } + }); + }, + error: function (code, message) { + if (!message) { + message = code; + code = Parse.Error.SCRIPT_FAILED; + } + reject(new Parse.Error(code, message)); + }, + message: message + }; + } + + static handleCloudFunction(req) { + const functionName = req.params.functionName; + const applicationId = req.config.applicationId; + const theFunction = triggers.getFunction(functionName, applicationId); + const theValidator = triggers.getValidator(req.params.functionName, applicationId); + if (theFunction) { + let params = Object.assign({}, req.body, req.query); + params = parseParams(params); + var request = { + params: params, + master: req.auth && req.auth.isMaster, + user: req.auth && req.auth.user, + installationId: req.info.installationId, + log: req.config.loggerController, + headers: req.config.headers, + ip: req.config.ip, + functionName + }; + + if (theValidator && typeof theValidator === "function") { + var result = theValidator(request); + if (!result) { + throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Validation failed.'); + } + } + + return new Promise(function (resolve, reject) { + const userString = req.auth && req.auth.user ? req.auth.user.id : undefined; + const cleanInput = _logger.logger.truncateLogMessage(JSON.stringify(params)); + var response = FunctionsRouter.createResponseObject(result => { + try { + const cleanResult = _logger.logger.truncateLogMessage(JSON.stringify(result.response.result)); + _logger.logger.info(`Ran cloud function ${functionName} for user ${userString} with:\n Input: ${cleanInput}\n Result: ${cleanResult}`, { + functionName, + params, + user: userString + }); + resolve(result); + } catch (e) { + reject(e); + } + }, error => { + try { + _logger.logger.error(`Failed running cloud function ${functionName} for user ${userString} with:\n Input: ${cleanInput}\n Error: ` + JSON.stringify(error), { + functionName, + error, + params, + user: userString + }); + reject(error); + } catch (e) { + reject(e); + } + }); + // Force the keys before the function calls. + Parse.applicationId = req.config.applicationId; + Parse.javascriptKey = req.config.javascriptKey; + Parse.masterKey = req.config.masterKey; + theFunction(request, response); + }); + } else { + throw new Parse.Error(Parse.Error.SCRIPT_FAILED, `Invalid function: "${functionName}"`); + } + } +} +exports.FunctionsRouter = FunctionsRouter; \ No newline at end of file diff --git a/lib/Routers/GlobalConfigRouter.js b/lib/Routers/GlobalConfigRouter.js new file mode 100644 index 0000000000..140960dfe8 --- /dev/null +++ b/lib/Routers/GlobalConfigRouter.js @@ -0,0 +1,61 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.GlobalConfigRouter = undefined; + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class GlobalConfigRouter extends _PromiseRouter2.default { + getGlobalConfig(req) { + return req.config.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: {} } }; + } + const globalConfig = results[0]; + return { response: { params: globalConfig.params } }; + }); + } + + updateGlobalConfig(req) { + if (req.auth.isReadOnly) { + throw new _node2.default.Error(_node2.default.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to update the config.'); + } + const params = req.body.params; + // Transform in dot notation to make sure it works + const update = Object.keys(params).reduce((acc, key) => { + acc[`params.${key}`] = params[key]; + return acc; + }, {}); + return req.config.database.update('_GlobalConfig', { objectId: "1" }, update, { upsert: true }).then(() => ({ response: { result: true } })); + } + + mountRoutes() { + this.route('GET', '/config', req => { + return this.getGlobalConfig(req); + }); + this.route('PUT', '/config', middleware.promiseEnforceMasterKeyAccess, req => { + return this.updateGlobalConfig(req); + }); + } +} + +exports.GlobalConfigRouter = GlobalConfigRouter; // global_config.js + +exports.default = GlobalConfigRouter; \ No newline at end of file diff --git a/lib/Routers/HooksRouter.js b/lib/Routers/HooksRouter.js new file mode 100644 index 0000000000..07a6933ea2 --- /dev/null +++ b/lib/Routers/HooksRouter.js @@ -0,0 +1,117 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.HooksRouter = undefined; + +var _node = require('parse/node'); + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class HooksRouter extends _PromiseRouter2.default { + createHook(aHook, config) { + return config.hooksController.createHook(aHook).then(hook => ({ response: hook })); + } + + updateHook(aHook, config) { + return config.hooksController.updateHook(aHook).then(hook => ({ response: hook })); + } + + handlePost(req) { + return this.createHook(req.body, req.config); + } + + handleGetFunctions(req) { + var hooksController = req.config.hooksController; + if (req.params.functionName) { + return hooksController.getFunction(req.params.functionName).then(foundFunction => { + if (!foundFunction) { + throw new _node.Parse.Error(143, `no function named: ${req.params.functionName} is defined`); + } + return Promise.resolve({ response: foundFunction }); + }); + } + + return hooksController.getFunctions().then(functions => { + return { response: functions || [] }; + }, err => { + throw err; + }); + } + + handleGetTriggers(req) { + var hooksController = req.config.hooksController; + if (req.params.className && req.params.triggerName) { + + return hooksController.getTrigger(req.params.className, req.params.triggerName).then(foundTrigger => { + if (!foundTrigger) { + throw new _node.Parse.Error(143, `class ${req.params.className} does not exist`); + } + return Promise.resolve({ response: foundTrigger }); + }); + } + + return hooksController.getTriggers().then(triggers => ({ response: triggers || [] })); + } + + handleDelete(req) { + var hooksController = req.config.hooksController; + if (req.params.functionName) { + return hooksController.deleteFunction(req.params.functionName).then(() => ({ response: {} })); + } else if (req.params.className && req.params.triggerName) { + return hooksController.deleteTrigger(req.params.className, req.params.triggerName).then(() => ({ response: {} })); + } + return Promise.resolve({ response: {} }); + } + + handleUpdate(req) { + var hook; + if (req.params.functionName && req.body.url) { + hook = {}; + hook.functionName = req.params.functionName; + hook.url = req.body.url; + } else if (req.params.className && req.params.triggerName && req.body.url) { + hook = {}; + hook.className = req.params.className; + hook.triggerName = req.params.triggerName; + hook.url = req.body.url; + } else { + throw new _node.Parse.Error(143, "invalid hook declaration"); + } + return this.updateHook(hook, req.config); + } + + handlePut(req) { + var body = req.body; + if (body.__op == "Delete") { + return this.handleDelete(req); + } else { + return this.handleUpdate(req); + } + } + + mountRoutes() { + this.route('GET', '/hooks/functions', middleware.promiseEnforceMasterKeyAccess, this.handleGetFunctions.bind(this)); + this.route('GET', '/hooks/triggers', middleware.promiseEnforceMasterKeyAccess, this.handleGetTriggers.bind(this)); + this.route('GET', '/hooks/functions/:functionName', middleware.promiseEnforceMasterKeyAccess, this.handleGetFunctions.bind(this)); + this.route('GET', '/hooks/triggers/:className/:triggerName', middleware.promiseEnforceMasterKeyAccess, this.handleGetTriggers.bind(this)); + this.route('POST', '/hooks/functions', middleware.promiseEnforceMasterKeyAccess, this.handlePost.bind(this)); + this.route('POST', '/hooks/triggers', middleware.promiseEnforceMasterKeyAccess, this.handlePost.bind(this)); + this.route('PUT', '/hooks/functions/:functionName', middleware.promiseEnforceMasterKeyAccess, this.handlePut.bind(this)); + this.route('PUT', '/hooks/triggers/:className/:triggerName', middleware.promiseEnforceMasterKeyAccess, this.handlePut.bind(this)); + } +} + +exports.HooksRouter = HooksRouter; +exports.default = HooksRouter; \ No newline at end of file diff --git a/lib/Routers/IAPValidationRouter.js b/lib/Routers/IAPValidationRouter.js new file mode 100644 index 0000000000..0d03e91f41 --- /dev/null +++ b/lib/Routers/IAPValidationRouter.js @@ -0,0 +1,125 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.IAPValidationRouter = undefined; + +var _PromiseRouter = require("../PromiseRouter"); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _node = require("parse/node"); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var request = require("request"); +var rest = require("../rest"); + + +// TODO move validation logic in IAPValidationController +const IAP_SANDBOX_URL = "https://sandbox.itunes.apple.com/verifyReceipt"; +const IAP_PRODUCTION_URL = "https://buy.itunes.apple.com/verifyReceipt"; + +const APP_STORE_ERRORS = { + 21000: "The App Store could not read the JSON object you provided.", + 21002: "The data in the receipt-data property was malformed or missing.", + 21003: "The receipt could not be authenticated.", + 21004: "The shared secret you provided does not match the shared secret on file for your account.", + 21005: "The receipt server is not currently available.", + 21006: "This receipt is valid but the subscription has expired.", + 21007: "This receipt is from the test environment, but it was sent to the production environment for verification. Send it to the test environment instead.", + 21008: "This receipt is from the production environment, but it was sent to the test environment for verification. Send it to the production environment instead." +}; + +function appStoreError(status) { + status = parseInt(status); + var errorString = APP_STORE_ERRORS[status] || "unknown error."; + return { status: status, error: errorString }; +} + +function validateWithAppStore(url, receipt) { + return new Promise(function (fulfill, reject) { + request.post({ + url: url, + body: { "receipt-data": receipt }, + json: true + }, function (err, res, body) { + var status = body.status; + if (status == 0) { + // No need to pass anything, status is OK + return fulfill(); + } + // receipt is from test and should go to test + return reject(body); + }); + }); +} + +function getFileForProductIdentifier(productIdentifier, req) { + return rest.find(req.config, req.auth, '_Product', { productIdentifier: productIdentifier }, undefined, req.info.clientSDK).then(function (result) { + const products = result.results; + if (!products || products.length != 1) { + // Error not found or too many + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Object not found.'); + } + + var download = products[0].download; + return Promise.resolve({ response: download }); + }); +} + +class IAPValidationRouter extends _PromiseRouter2.default { + + handleRequest(req) { + let receipt = req.body.receipt; + const productIdentifier = req.body.productIdentifier; + + if (!receipt || !productIdentifier) { + // TODO: Error, malformed request + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, "missing receipt or productIdentifier"); + } + + // Transform the object if there + // otherwise assume it's in Base64 already + if (typeof receipt == "object") { + if (receipt["__type"] == "Bytes") { + receipt = receipt.base64; + } + } + + if (process.env.TESTING == "1" && req.body.bypassAppStoreValidation) { + return getFileForProductIdentifier(productIdentifier, req); + } + + function successCallback() { + return getFileForProductIdentifier(productIdentifier, req); + } + + function errorCallback(error) { + return Promise.resolve({ response: appStoreError(error.status) }); + } + + return validateWithAppStore(IAP_PRODUCTION_URL, receipt).then(() => { + + return successCallback(); + }, error => { + if (error.status == 21007) { + return validateWithAppStore(IAP_SANDBOX_URL, receipt).then(() => { + return successCallback(); + }, error => { + return errorCallback(error); + }); + } + + return errorCallback(error); + }); + } + + mountRoutes() { + this.route("POST", "/validate_purchase", this.handleRequest); + } +} +exports.IAPValidationRouter = IAPValidationRouter; \ No newline at end of file diff --git a/lib/Routers/ImportRouter.js b/lib/Routers/ImportRouter.js new file mode 100644 index 0000000000..726bda099b --- /dev/null +++ b/lib/Routers/ImportRouter.js @@ -0,0 +1,208 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ImportRouter = undefined; + +var _express = require('express'); + +var _express2 = _interopRequireDefault(_express); + +var _AdapterLoader = require('../Adapters/AdapterLoader'); + +var _middlewares = require('../middlewares'); + +var middlewares = _interopRequireWildcard(_middlewares); + +var _multer = require('multer'); + +var _multer2 = _interopRequireDefault(_multer); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _node = require('parse/node'); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class ImportRouter { + + getOneSchema(req) { + + const className = req.params.className; + + return req.config.database.loadSchema({ clearCache: true }).then(schemaController => schemaController.getOneSchema(className)).catch(error => { + if (error === undefined) { + return Promise.reject(new _node.Parse.Error(_node.Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`)); + } else { + return Promise.reject(new _node.Parse.Error(_node.Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.')); + } + }); + } + + importRestObject(req, restObject, targetClass) { + if (targetClass) { + return _rest2.default.update(req.config, req.auth, req.params.className, { objectId: restObject.owningId }, { + [req.params.relationName]: { + "__op": "AddRelation", + "objects": [{ "__type": "Pointer", "className": targetClass, "objectId": restObject.relatedId }] + } + }, req.info.clientSDK).catch(function (error) { + if (error.code === _node.Parse.Error.OBJECT_NOT_FOUND) { + return Promise.reject(new _node.Parse.Error(_node.Parse.Error.OBJECT_NOT_FOUND, 'Object not found')); + } else { + return Promise.reject(error); + } + }); + } + + if (restObject.createdAt) { + delete restObject.createdAt; + } + + if (restObject.updatedAt) { + delete restObject.updatedAt; + } + + if (restObject.objectId) { + return _rest2.default.update(req.config, req.auth, req.params.className, { objectId: restObject.objectId }, restObject, req.info.clientSDK).catch(function (error) { + if (error.code === _node.Parse.Error.OBJECT_NOT_FOUND) { + return _rest2.default.create(req.config, req.auth, req.params.className, restObject, req.info.clientSDK, { allowObjectId: true }); + } else { + return Promise.reject(error); + } + }); + } + + return _rest2.default.create(req.config, req.auth, req.params.className, restObject); + } + + getRestObjects(req) { + return new Promise(resolve => { + + let restObjects = []; + let importFile; + + try { + importFile = JSON.parse(req.file.buffer.toString()); + } catch (e) { + throw new Error('Failed to parse JSON based on the file sent'); + } + + if (Array.isArray(importFile)) { + restObjects = importFile; + } else if (Array.isArray(importFile.results)) { + restObjects = importFile.results; + } else if (Array.isArray(importFile.rows)) { + restObjects = importFile.rows; + } + + if (!restObjects) { + throw new Error('No data to import'); + } + + if (req.body.feedbackEmail) { + if (!req.config.emailAdapter) { + throw new Error('You have to setup a Mail Adapter.'); + } + } + + resolve(restObjects); + }); + } + + handleImport(req) { + + const emailControllerAdapter = (0, _AdapterLoader.loadAdapter)(req.config.emailAdapter); + + let promise = null; + + if (req.params.relationName) { + promise = this.getOneSchema(req).then(response => { + if (!response.fields.hasOwnProperty(req.params.relationName)) { + throw new Error(`Relation ${req.params.relationName} does not exist in ${req.params.className}.`); + } else if (response.fields[req.params.relationName].type !== 'Relation') { + throw new Error(`Class ${response.fields[req.params.relationName].targetClass} does not have Relation type.`); + } + + const targetClass = response.fields[req.params.relationName].targetClass; + + return Promise.all([this.getRestObjects(req), targetClass]); + }); + } else { + promise = Promise.all([this.getRestObjects(req)]); + } + + promise = promise.then(([restObjects, targetClass]) => { + + return restObjects.reduce((item, object, index) => { + + item.pageArray.push(this.importRestObject.bind(this, req, object, targetClass)); + + if (index && index % 100 === 0 || index === restObjects.length - 1) { + + const pageArray = item.pageArray.slice(0); + item.pageArray = []; + + item.mainPromise = item.mainPromise.then(results => { + return Promise.all(results.concat(pageArray.map(func => func()))); + }); + } + + return item; + }, { pageArray: [], mainPromise: Promise.resolve([]) }).mainPromise; + }).then(results => { + if (req.body.feedbackEmail) { + emailControllerAdapter.sendMail({ + text: `We have successfully imported your data to the class ${req.params.className}${req.params.relationName ? ', relation ' + req.params.relationName : ''}.`, + to: req.body.feedbackEmail, + subject: 'Import completed' + }); + } else { + return Promise.resolve({ response: results }); + } + }).catch(error => { + if (req.body.feedbackEmail) { + emailControllerAdapter.sendMail({ + text: `We could not import your data to the class ${req.params.className}${req.params.relationName ? ', relation ' + req.params.relationName : ''}. Error: ${error}`, + to: req.body.feedbackEmail, + subject: 'Import failed' + }); + } else { + throw new Error('Internal server error: ' + error); + } + }); + + if (req.body.feedbackEmail && emailControllerAdapter) { + promise = Promise.resolve({ response: 'We are importing your data. You will be notified by e-mail once it is completed.' }); + } + + return promise; + } + + wrapPromiseRequest(req, res, handler) { + return handler(req).then(data => { + res.json(data); + }).catch(err => { + res.status(400).send({ message: err.message }); + }); + } + + expressRouter() { + const router = _express2.default.Router(); + const upload = (0, _multer2.default)(); + + router.post('/import_data/:className', upload.single('importFile'), middlewares.allowCrossDomain, middlewares.handleParseHeaders, middlewares.enforceMasterKeyAccess, (req, res) => this.wrapPromiseRequest(req, res, this.handleImport.bind(this))); + + router.post('/import_relation_data/:className/:relationName', upload.single('importFile'), middlewares.allowCrossDomain, middlewares.handleParseHeaders, middlewares.enforceMasterKeyAccess, (req, res) => this.wrapPromiseRequest(req, res, this.handleImport.bind(this))); + + return router; + } +} + +exports.ImportRouter = ImportRouter; +exports.default = ImportRouter; \ No newline at end of file diff --git a/lib/Routers/InstallationsRouter.js b/lib/Routers/InstallationsRouter.js new file mode 100644 index 0000000000..becd25b183 --- /dev/null +++ b/lib/Routers/InstallationsRouter.js @@ -0,0 +1,53 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.InstallationsRouter = undefined; + +var _ClassesRouter = require('./ClassesRouter'); + +var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// InstallationsRouter.js + +class InstallationsRouter extends _ClassesRouter2.default { + className() { + return '_Installation'; + } + + handleFind(req) { + const body = Object.assign(req.body, _ClassesRouter2.default.JSONFromQuery(req.query)); + const options = _ClassesRouter2.default.optionsFromBody(body); + return _rest2.default.find(req.config, req.auth, '_Installation', body.where, options, req.info.clientSDK).then(response => { + return { response: response }; + }); + } + + mountRoutes() { + this.route('GET', '/installations', req => { + return this.handleFind(req); + }); + this.route('GET', '/installations/:objectId', req => { + return this.handleGet(req); + }); + this.route('POST', '/installations', req => { + return this.handleCreate(req); + }); + this.route('PUT', '/installations/:objectId', req => { + return this.handleUpdate(req); + }); + this.route('DELETE', '/installations/:objectId', req => { + return this.handleDelete(req); + }); + } +} + +exports.InstallationsRouter = InstallationsRouter; +exports.default = InstallationsRouter; \ No newline at end of file diff --git a/lib/Routers/LogsRouter.js b/lib/Routers/LogsRouter.js new file mode 100644 index 0000000000..99ed475a83 --- /dev/null +++ b/lib/Routers/LogsRouter.js @@ -0,0 +1,71 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.LogsRouter = undefined; + +var _node = require('parse/node'); + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class LogsRouter extends _PromiseRouter2.default { + + mountRoutes() { + this.route('GET', '/scriptlog', middleware.promiseEnforceMasterKeyAccess, this.validateRequest, req => { + return this.handleGET(req); + }); + } + + validateRequest(req) { + if (!req.config || !req.config.loggerController) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Logger adapter is not available'); + } + } + + // Returns a promise for a {response} object. + // query params: + // level (optional) Level of logging you want to query for (info || error) + // from (optional) Start time for the search. Defaults to 1 week ago. + // until (optional) End time for the search. Defaults to current time. + // order (optional) Direction of results returned, either “asc” or “desc”. Defaults to “desc”. + // size (optional) Number of rows returned by search. Defaults to 10 + // n same as size, overrides size if set + handleGET(req) { + const from = req.query.from; + const until = req.query.until; + let size = req.query.size; + if (req.query.n) { + size = req.query.n; + } + + const order = req.query.order; + const level = req.query.level; + const options = { + from, + until, + size, + order, + level + }; + + return req.config.loggerController.getLogs(options).then(result => { + return Promise.resolve({ + response: result + }); + }); + } +} + +exports.LogsRouter = LogsRouter; +exports.default = LogsRouter; \ No newline at end of file diff --git a/lib/Routers/PublicAPIRouter.js b/lib/Routers/PublicAPIRouter.js new file mode 100644 index 0000000000..ef29364807 --- /dev/null +++ b/lib/Routers/PublicAPIRouter.js @@ -0,0 +1,271 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PublicAPIRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _Config = require('../Config'); + +var _Config2 = _interopRequireDefault(_Config); + +var _express = require('express'); + +var _express2 = _interopRequireDefault(_express); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _fs = require('fs'); + +var _fs2 = _interopRequireDefault(_fs); + +var _querystring = require('querystring'); + +var _querystring2 = _interopRequireDefault(_querystring); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const public_html = _path2.default.resolve(__dirname, "../../public_html"); +const views = _path2.default.resolve(__dirname, '../../views'); + +class PublicAPIRouter extends _PromiseRouter2.default { + + verifyEmail(req) { + const { token, username } = req.query; + const appId = req.params.appId; + const config = _Config2.default.get(appId); + + if (!config) { + this.invalidRequest(); + } + + if (!config.publicServerURL) { + return this.missingPublicServerURL(); + } + + if (!token || !username) { + return this.invalidLink(req); + } + + const userController = config.userController; + return userController.verifyEmail(username, token).then(() => { + const params = _querystring2.default.stringify({ username }); + return Promise.resolve({ + status: 302, + location: `${config.verifyEmailSuccessURL}?${params}` + }); + }, () => { + return this.invalidVerificationLink(req); + }); + } + + resendVerificationEmail(req) { + const username = req.body.username; + const appId = req.params.appId; + const config = _Config2.default.get(appId); + + if (!config) { + this.invalidRequest(); + } + + if (!config.publicServerURL) { + return this.missingPublicServerURL(); + } + + if (!username) { + return this.invalidLink(req); + } + + const userController = config.userController; + + return userController.resendVerificationEmail(username).then(() => { + return Promise.resolve({ + status: 302, + location: `${config.linkSendSuccessURL}` + }); + }, () => { + return Promise.resolve({ + status: 302, + location: `${config.linkSendFailURL}` + }); + }); + } + + changePassword(req) { + return new Promise((resolve, reject) => { + const config = _Config2.default.get(req.query.id); + + if (!config) { + this.invalidRequest(); + } + + if (!config.publicServerURL) { + return resolve({ + status: 404, + text: 'Not found.' + }); + } + // Should we keep the file in memory or leave like that? + _fs2.default.readFile(_path2.default.resolve(views, "choose_password"), 'utf-8', (err, data) => { + if (err) { + return reject(err); + } + data = data.replace("PARSE_SERVER_URL", `'${config.publicServerURL}'`); + resolve({ + text: data + }); + }); + }); + } + + requestResetPassword(req) { + + const config = req.config; + + if (!config) { + this.invalidRequest(); + } + + if (!config.publicServerURL) { + return this.missingPublicServerURL(); + } + + const { username, token } = req.query; + + if (!username || !token) { + return this.invalidLink(req); + } + + return config.userController.checkResetTokenValidity(username, token).then(() => { + const params = _querystring2.default.stringify({ token, id: config.applicationId, username, app: config.appName }); + return Promise.resolve({ + status: 302, + location: `${config.choosePasswordURL}?${params}` + }); + }, () => { + return this.invalidLink(req); + }); + } + + resetPassword(req) { + + const config = req.config; + + if (!config) { + this.invalidRequest(); + } + + if (!config.publicServerURL) { + return this.missingPublicServerURL(); + } + + const { + username, + token, + new_password + } = req.body; + + if (!username || !token || !new_password) { + return this.invalidLink(req); + } + + return config.userController.updatePassword(username, token, new_password).then(() => { + const params = _querystring2.default.stringify({ username: username }); + return Promise.resolve({ + status: 302, + location: `${config.passwordResetSuccessURL}?${params}` + }); + }, err => { + const params = _querystring2.default.stringify({ username: username, token: token, id: config.applicationId, error: err, app: config.appName }); + return Promise.resolve({ + status: 302, + location: `${config.choosePasswordURL}?${params}` + }); + }); + } + + invalidLink(req) { + return Promise.resolve({ + status: 302, + location: req.config.invalidLinkURL + }); + } + + invalidVerificationLink(req) { + const config = req.config; + if (req.query.username && req.params.appId) { + const params = _querystring2.default.stringify({ username: req.query.username, appId: req.params.appId }); + return Promise.resolve({ + status: 302, + location: `${config.invalidVerificationLinkURL}?${params}` + }); + } else { + return this.invalidLink(req); + } + } + + missingPublicServerURL() { + return Promise.resolve({ + text: 'Not found.', + status: 404 + }); + } + + invalidRequest() { + const error = new Error(); + error.status = 403; + error.message = "unauthorized"; + throw error; + } + + setConfig(req) { + req.config = _Config2.default.get(req.params.appId); + return Promise.resolve(); + } + + mountRoutes() { + this.route('GET', '/apps/:appId/verify_email', req => { + this.setConfig(req); + }, req => { + return this.verifyEmail(req); + }); + + this.route('POST', '/apps/:appId/resend_verification_email', req => { + this.setConfig(req); + }, req => { + return this.resendVerificationEmail(req); + }); + + this.route('GET', '/apps/choose_password', req => { + return this.changePassword(req); + }); + + this.route('POST', '/apps/:appId/request_password_reset', req => { + this.setConfig(req); + }, req => { + return this.resetPassword(req); + }); + + this.route('GET', '/apps/:appId/request_password_reset', req => { + this.setConfig(req); + }, req => { + return this.requestResetPassword(req); + }); + } + + expressRouter() { + const router = _express2.default.Router(); + router.use("/apps", _express2.default.static(public_html)); + router.use("/", super.expressRouter()); + return router; + } +} + +exports.PublicAPIRouter = PublicAPIRouter; +exports.default = PublicAPIRouter; \ No newline at end of file diff --git a/lib/Routers/PurgeRouter.js b/lib/Routers/PurgeRouter.js new file mode 100644 index 0000000000..7f55981c42 --- /dev/null +++ b/lib/Routers/PurgeRouter.js @@ -0,0 +1,42 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PurgeRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class PurgeRouter extends _PromiseRouter2.default { + + handlePurge(req) { + return req.config.database.purgeCollection(req.params.className).then(() => { + var cacheAdapter = req.config.cacheController; + if (req.params.className == '_Session') { + cacheAdapter.user.clear(); + } else if (req.params.className == '_Role') { + cacheAdapter.role.clear(); + } + return { response: {} }; + }); + } + + mountRoutes() { + this.route('DELETE', '/purge/:className', middleware.promiseEnforceMasterKeyAccess, req => { + return this.handlePurge(req); + }); + } +} + +exports.PurgeRouter = PurgeRouter; +exports.default = PurgeRouter; \ No newline at end of file diff --git a/lib/Routers/PushRouter.js b/lib/Routers/PushRouter.js new file mode 100644 index 0000000000..a0cb95c9cf --- /dev/null +++ b/lib/Routers/PushRouter.js @@ -0,0 +1,88 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PushRouter = undefined; + +var _PromiseRouter = require("../PromiseRouter"); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require("../middlewares"); + +var middleware = _interopRequireWildcard(_middlewares); + +var _node = require("parse/node"); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class PushRouter extends _PromiseRouter2.default { + + mountRoutes() { + this.route("POST", "/push", middleware.promiseEnforceMasterKeyAccess, PushRouter.handlePOST); + } + + static handlePOST(req) { + if (req.auth.isReadOnly) { + throw new _node.Parse.Error(_node.Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to send push notifications.'); + } + const pushController = req.config.pushController; + if (!pushController) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Push controller is not set'); + } + + const where = PushRouter.getQueryCondition(req); + let resolve; + const promise = new Promise(_resolve => { + resolve = _resolve; + }); + let pushStatusId; + pushController.sendPush(req.body, where, req.config, req.auth, objectId => { + pushStatusId = objectId; + resolve({ + headers: { + 'X-Parse-Push-Status-Id': pushStatusId + }, + response: { + result: true + } + }); + }).catch(err => { + req.config.loggerController.error(`_PushStatus ${pushStatusId}: error while sending push`, err); + }); + return promise; + } + + /** + * Get query condition from the request body. + * @param {Object} req A request object + * @returns {Object} The query condition, the where field in a query api call + */ + static getQueryCondition(req) { + const body = req.body || {}; + const hasWhere = typeof body.where !== 'undefined'; + const hasChannels = typeof body.channels !== 'undefined'; + + let where; + if (hasWhere && hasChannels) { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Channels and query can not be set at the same time.'); + } else if (hasWhere) { + where = body.where; + } else if (hasChannels) { + where = { + "channels": { + "$in": body.channels + } + }; + } else { + throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Sending a push requires either "channels" or a "where" query.'); + } + return where; + } +} + +exports.PushRouter = PushRouter; +exports.default = PushRouter; \ No newline at end of file diff --git a/lib/Routers/RolesRouter.js b/lib/Routers/RolesRouter.js new file mode 100644 index 0000000000..05ae6cccf6 --- /dev/null +++ b/lib/Routers/RolesRouter.js @@ -0,0 +1,39 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.RolesRouter = undefined; + +var _ClassesRouter = require('./ClassesRouter'); + +var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class RolesRouter extends _ClassesRouter2.default { + className() { + return '_Role'; + } + + mountRoutes() { + this.route('GET', '/roles', req => { + return this.handleFind(req); + }); + this.route('GET', '/roles/:objectId', req => { + return this.handleGet(req); + }); + this.route('POST', '/roles', req => { + return this.handleCreate(req); + }); + this.route('PUT', '/roles/:objectId', req => { + return this.handleUpdate(req); + }); + this.route('DELETE', '/roles/:objectId', req => { + return this.handleDelete(req); + }); + } +} + +exports.RolesRouter = RolesRouter; +exports.default = RolesRouter; \ No newline at end of file diff --git a/lib/Routers/SchemasRouter.js b/lib/Routers/SchemasRouter.js new file mode 100644 index 0000000000..01f909fcd6 --- /dev/null +++ b/lib/Routers/SchemasRouter.js @@ -0,0 +1,96 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.SchemasRouter = undefined; + +var _PromiseRouter = require('../PromiseRouter'); + +var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter); + +var _middlewares = require('../middlewares'); + +var middleware = _interopRequireWildcard(_middlewares); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// schemas.js + +var Parse = require('parse/node').Parse, + SchemaController = require('../Controllers/SchemaController'); + +function classNameMismatchResponse(bodyClass, pathClass) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class name mismatch between ${bodyClass} and ${pathClass}.`); +} + +function getAllSchemas(req) { + return req.config.database.loadSchema({ clearCache: true }).then(schemaController => schemaController.getAllClasses(true)).then(schemas => ({ response: { results: schemas } })); +} + +function getOneSchema(req) { + const className = req.params.className; + return req.config.database.loadSchema({ clearCache: true }).then(schemaController => schemaController.getOneSchema(className, true)).then(schema => ({ response: schema })).catch(error => { + if (error === undefined) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`); + } else { + throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.'); + } + }); +} + +function createSchema(req) { + if (req.auth.isReadOnly) { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to create a schema.'); + } + if (req.params.className && req.body.className) { + if (req.params.className != req.body.className) { + return classNameMismatchResponse(req.body.className, req.params.className); + } + } + + const className = req.params.className || req.body.className; + if (!className) { + throw new Parse.Error(135, `POST ${req.path} needs a class name.`); + } + + return req.config.database.loadSchema({ clearCache: true }).then(schema => schema.addClassIfNotExists(className, req.body.fields, req.body.classLevelPermissions, req.body.indexes)).then(schema => ({ response: schema })); +} + +function modifySchema(req) { + if (req.auth.isReadOnly) { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to update a schema.'); + } + if (req.body.className && req.body.className != req.params.className) { + return classNameMismatchResponse(req.body.className, req.params.className); + } + + const submittedFields = req.body.fields || {}; + const className = req.params.className; + + return req.config.database.loadSchema({ clearCache: true }).then(schema => schema.updateClass(className, submittedFields, req.body.classLevelPermissions, req.body.indexes, req.config.database)).then(result => ({ response: result })); +} + +const deleteSchema = req => { + if (req.auth.isReadOnly) { + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to delete a schema.'); + } + if (!SchemaController.classNameIsValid(req.params.className)) { + throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, SchemaController.invalidClassNameMessage(req.params.className)); + } + return req.config.database.deleteSchema(req.params.className).then(() => ({ response: {} })); +}; + +class SchemasRouter extends _PromiseRouter2.default { + mountRoutes() { + this.route('GET', '/schemas', middleware.promiseEnforceMasterKeyAccess, getAllSchemas); + this.route('GET', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, getOneSchema); + this.route('POST', '/schemas', middleware.promiseEnforceMasterKeyAccess, createSchema); + this.route('POST', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, createSchema); + this.route('PUT', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, modifySchema); + this.route('DELETE', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, deleteSchema); + } +} +exports.SchemasRouter = SchemasRouter; \ No newline at end of file diff --git a/lib/Routers/SessionsRouter.js b/lib/Routers/SessionsRouter.js new file mode 100644 index 0000000000..dc614896ee --- /dev/null +++ b/lib/Routers/SessionsRouter.js @@ -0,0 +1,116 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.SessionsRouter = undefined; + +var _ClassesRouter = require('./ClassesRouter'); + +var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _Auth = require('../Auth'); + +var _Auth2 = _interopRequireDefault(_Auth); + +var _RestWrite = require('../RestWrite'); + +var _RestWrite2 = _interopRequireDefault(_RestWrite); + +var _cryptoUtils = require('../cryptoUtils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class SessionsRouter extends _ClassesRouter2.default { + + className() { + return '_Session'; + } + + handleMe(req) { + // TODO: Verify correct behavior + if (!req.info || !req.info.sessionToken) { + throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'Session token required.'); + } + return _rest2.default.find(req.config, _Auth2.default.master(req.config), '_Session', { sessionToken: req.info.sessionToken }, undefined, req.info.clientSDK).then(response => { + if (!response.results || response.results.length == 0) { + throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'Session token not found.'); + } + return { + response: response.results[0] + }; + }); + } + + handleUpdateToRevocableSession(req) { + const config = req.config; + const masterAuth = _Auth2.default.master(config); + const user = req.auth.user; + // Issue #2720 + // Calling without a session token would result in a not found user + if (!user) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'invalid session'); + } + const expiresAt = config.generateSessionExpiresAt(); + const sessionData = { + sessionToken: 'r:' + (0, _cryptoUtils.newToken)(), + user: { + __type: 'Pointer', + className: '_User', + objectId: user.id + }, + createdWith: { + 'action': 'upgrade' + }, + restricted: false, + installationId: req.auth.installationId, + expiresAt: _node2.default._encode(expiresAt) + }; + const create = new _RestWrite2.default(config, masterAuth, '_Session', null, sessionData); + return create.execute().then(() => { + // delete the session token, use the db to skip beforeSave + return config.database.update('_User', { + objectId: user.id + }, { + sessionToken: { __op: 'Delete' } + }); + }).then(() => { + return Promise.resolve({ response: sessionData }); + }); + } + + mountRoutes() { + this.route('GET', '/sessions/me', req => { + return this.handleMe(req); + }); + this.route('GET', '/sessions', req => { + return this.handleFind(req); + }); + this.route('GET', '/sessions/:objectId', req => { + return this.handleGet(req); + }); + this.route('POST', '/sessions', req => { + return this.handleCreate(req); + }); + this.route('PUT', '/sessions/:objectId', req => { + return this.handleUpdate(req); + }); + this.route('DELETE', '/sessions/:objectId', req => { + return this.handleDelete(req); + }); + this.route('POST', '/upgradeToRevocableSession', req => { + return this.handleUpdateToRevocableSession(req); + }); + } +} + +exports.SessionsRouter = SessionsRouter; +exports.default = SessionsRouter; \ No newline at end of file diff --git a/lib/Routers/UsersRouter.js b/lib/Routers/UsersRouter.js new file mode 100644 index 0000000000..472c5e4efb --- /dev/null +++ b/lib/Routers/UsersRouter.js @@ -0,0 +1,325 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.UsersRouter = undefined; + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _Config = require('../Config'); + +var _Config2 = _interopRequireDefault(_Config); + +var _AccountLockout = require('../AccountLockout'); + +var _AccountLockout2 = _interopRequireDefault(_AccountLockout); + +var _ClassesRouter = require('./ClassesRouter'); + +var _ClassesRouter2 = _interopRequireDefault(_ClassesRouter); + +var _rest = require('../rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _Auth = require('../Auth'); + +var _Auth2 = _interopRequireDefault(_Auth); + +var _password = require('../password'); + +var _password2 = _interopRequireDefault(_password); + +var _RestWrite = require('../RestWrite'); + +var _RestWrite2 = _interopRequireDefault(_RestWrite); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// These methods handle the User-related routes. + +const cryptoUtils = require('../cryptoUtils'); + +class UsersRouter extends _ClassesRouter2.default { + + className() { + return '_User'; + } + + /** + * Removes all "_" prefixed properties from an object, except "__type" + * @param {Object} obj An object. + */ + static removeHiddenProperties(obj) { + for (var key in obj) { + if (obj.hasOwnProperty(key)) { + // Regexp comes from Parse.Object.prototype.validate + if (key !== "__type" && !/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) { + delete obj[key]; + } + } + } + } + + handleMe(req) { + if (!req.info || !req.info.sessionToken) { + throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + } + const sessionToken = req.info.sessionToken; + return _rest2.default.find(req.config, _Auth2.default.master(req.config), '_Session', { sessionToken }, { include: 'user' }, req.info.clientSDK).then(response => { + if (!response.results || response.results.length == 0 || !response.results[0].user) { + throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + } else { + const user = response.results[0].user; + // Send token back on the login, because SDKs expect that. + user.sessionToken = sessionToken; + + // Remove hidden properties. + UsersRouter.removeHiddenProperties(user); + + return { response: user }; + } + }); + } + + handleLogIn(req) { + // Use query parameters instead if provided in url + let payload = req.body; + if (!payload.username && req.query.username || !payload.email && req.query.email) { + payload = req.query; + } + const { + username, + email, + password + } = payload; + + // TODO: use the right error codes / descriptions. + if (!username && !email) { + throw new _node2.default.Error(_node2.default.Error.USERNAME_MISSING, 'username/email is required.'); + } + if (!password) { + throw new _node2.default.Error(_node2.default.Error.PASSWORD_MISSING, 'password is required.'); + } + if (typeof password !== 'string' || email && typeof email !== 'string' || username && typeof username !== 'string') { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + + let user; + let isValidPassword = false; + const query = Object.assign({}, username ? { username } : {}, email ? { email } : {}); + return req.config.database.find('_User', query).then(results => { + if (!results.length) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + user = results[0]; + + if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) { + throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, 'User email is not verified.'); + } + return _password2.default.compare(password, user.password); + }).then(correct => { + isValidPassword = correct; + const accountLockoutPolicy = new _AccountLockout2.default(user, req.config); + return accountLockoutPolicy.handleLoginAttempt(isValidPassword); + }).then(() => { + if (!isValidPassword) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + + // handle password expiry policy + if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) { + let changedAt = user._password_changed_at; + + if (!changedAt) { + // password was created before expiry policy was enabled. + // simply update _User object so that it will start enforcing from now + changedAt = new Date(); + req.config.database.update('_User', { username: user.username }, { _password_changed_at: _node2.default._encode(changedAt) }); + } else { + // check whether the password has expired + if (changedAt.__type == 'Date') { + changedAt = new Date(changedAt.iso); + } + // Calculate the expiry time. + const expiresAt = new Date(changedAt.getTime() + 86400000 * req.config.passwordPolicy.maxPasswordAge); + if (expiresAt < new Date()) // fail of current time is past password expiry time + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Your password has expired. Please reset your password.'); + } + } + + const token = 'r:' + cryptoUtils.newToken(); + user.sessionToken = token; + delete user.password; + + // Remove hidden properties. + UsersRouter.removeHiddenProperties(user); + + // Sometimes the authData still has null on that keys + // https://github.com/parse-community/parse-server/issues/935 + if (user.authData) { + Object.keys(user.authData).forEach(provider => { + if (user.authData[provider] === null) { + delete user.authData[provider]; + } + }); + if (Object.keys(user.authData).length == 0) { + delete user.authData; + } + } + + req.config.filesController.expandFilesInObject(req.config, user); + + const expiresAt = req.config.generateSessionExpiresAt(); + const sessionData = { + sessionToken: token, + user: { + __type: 'Pointer', + className: '_User', + objectId: user.objectId + }, + createdWith: { + 'action': 'login', + 'authProvider': 'password' + }, + restricted: false, + expiresAt: _node2.default._encode(expiresAt) + }; + + if (req.info.installationId) { + sessionData.installationId = req.info.installationId; + } + + const create = new _RestWrite2.default(req.config, _Auth2.default.master(req.config), '_Session', null, sessionData); + return create.execute(); + }).then(() => { + return { response: user }; + }); + } + + handleLogOut(req) { + const success = { response: {} }; + if (req.info && req.info.sessionToken) { + return _rest2.default.find(req.config, _Auth2.default.master(req.config), '_Session', { sessionToken: req.info.sessionToken }, undefined, req.info.clientSDK).then(records => { + if (records.results && records.results.length) { + return _rest2.default.del(req.config, _Auth2.default.master(req.config), '_Session', records.results[0].objectId).then(() => { + return Promise.resolve(success); + }); + } + return Promise.resolve(success); + }); + } + return Promise.resolve(success); + } + + _throwOnBadEmailConfig(req) { + try { + _Config2.default.validateEmailConfiguration({ + emailAdapter: req.config.userController.adapter, + appName: req.config.appName, + publicServerURL: req.config.publicServerURL, + emailVerifyTokenValidityDuration: req.config.emailVerifyTokenValidityDuration + }); + } catch (e) { + if (typeof e === 'string') { + // Maybe we need a Bad Configuration error, but the SDKs won't understand it. For now, Internal Server Error. + throw new _node2.default.Error(_node2.default.Error.INTERNAL_SERVER_ERROR, 'An appName, publicServerURL, and emailAdapter are required for password reset and email verification functionality.'); + } else { + throw e; + } + } + } + + handleResetRequest(req) { + this._throwOnBadEmailConfig(req); + + const { email } = req.body; + if (!email) { + throw new _node2.default.Error(_node2.default.Error.EMAIL_MISSING, "you must provide an email"); + } + if (typeof email !== 'string') { + throw new _node2.default.Error(_node2.default.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string'); + } + const userController = req.config.userController; + return userController.sendPasswordResetEmail(email).then(() => { + return Promise.resolve({ + response: {} + }); + }, err => { + if (err.code === _node2.default.Error.OBJECT_NOT_FOUND) { + throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, `No user found with email ${email}.`); + } else { + throw err; + } + }); + } + + handleVerificationEmailRequest(req) { + this._throwOnBadEmailConfig(req); + + const { email } = req.body; + if (!email) { + throw new _node2.default.Error(_node2.default.Error.EMAIL_MISSING, 'you must provide an email'); + } + if (typeof email !== 'string') { + throw new _node2.default.Error(_node2.default.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string'); + } + + return req.config.database.find('_User', { email: email }).then(results => { + if (!results.length || results.length < 1) { + throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, `No user found with email ${email}`); + } + const user = results[0]; + + if (user.emailVerified) { + throw new _node2.default.Error(_node2.default.Error.OTHER_CAUSE, `Email ${email} is already verified.`); + } + + const userController = req.config.userController; + userController.sendVerificationEmail(user); + return { response: {} }; + }); + } + + mountRoutes() { + this.route('GET', '/users', req => { + return this.handleFind(req); + }); + this.route('POST', '/users', req => { + return this.handleCreate(req); + }); + this.route('GET', '/users/me', req => { + return this.handleMe(req); + }); + this.route('GET', '/users/:objectId', req => { + return this.handleGet(req); + }); + this.route('PUT', '/users/:objectId', req => { + return this.handleUpdate(req); + }); + this.route('DELETE', '/users/:objectId', req => { + return this.handleDelete(req); + }); + this.route('GET', '/login', req => { + return this.handleLogIn(req); + }); + this.route('POST', '/login', req => { + return this.handleLogIn(req); + }); + this.route('POST', '/logout', req => { + return this.handleLogOut(req); + }); + this.route('POST', '/requestPasswordReset', req => { + return this.handleResetRequest(req); + }); + this.route('POST', '/verificationEmailRequest', req => { + return this.handleVerificationEmailRequest(req); + }); + } +} + +exports.UsersRouter = UsersRouter; +exports.default = UsersRouter; \ No newline at end of file diff --git a/lib/StatusHandler.js b/lib/StatusHandler.js new file mode 100644 index 0000000000..1abf9778a2 --- /dev/null +++ b/lib/StatusHandler.js @@ -0,0 +1,324 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.flatten = flatten; +exports.jobStatusHandler = jobStatusHandler; +exports.pushStatusHandler = pushStatusHandler; + +var _cryptoUtils = require('./cryptoUtils'); + +var _logger = require('./logger'); + +var _rest = require('./rest'); + +var _rest2 = _interopRequireDefault(_rest); + +var _Auth = require('./Auth'); + +var _Auth2 = _interopRequireDefault(_Auth); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const PUSH_STATUS_COLLECTION = '_PushStatus'; +const JOB_STATUS_COLLECTION = '_JobStatus'; + +const incrementOp = function (object = {}, key, amount = 1) { + if (!object[key]) { + object[key] = { __op: 'Increment', amount: amount }; + } else { + object[key].amount += amount; + } + return object[key]; +}; + +function flatten(array) { + var flattened = []; + for (var i = 0; i < array.length; i++) { + if (Array.isArray(array[i])) { + flattened = flattened.concat(flatten(array[i])); + } else { + flattened.push(array[i]); + } + } + return flattened; +} + +function statusHandler(className, database) { + let lastPromise = Promise.resolve(); + + function create(object) { + lastPromise = lastPromise.then(() => { + return database.create(className, object).then(() => { + return Promise.resolve(object); + }); + }); + return lastPromise; + } + + function update(where, object) { + lastPromise = lastPromise.then(() => { + return database.update(className, where, object); + }); + return lastPromise; + } + + return Object.freeze({ + create, + update + }); +} + +function restStatusHandler(className, config) { + let lastPromise = Promise.resolve(); + const auth = _Auth2.default.master(config); + function create(object) { + lastPromise = lastPromise.then(() => { + return _rest2.default.create(config, auth, className, object).then(({ response }) => { + // merge the objects + return Promise.resolve(Object.assign({}, object, response)); + }); + }); + return lastPromise; + } + + function update(where, object) { + // TODO: when we have updateWhere, use that for proper interfacing + lastPromise = lastPromise.then(() => { + return _rest2.default.update(config, auth, className, { objectId: where.objectId }, object).then(({ response }) => { + // merge the objects + return Promise.resolve(Object.assign({}, object, response)); + }); + }); + return lastPromise; + } + + return Object.freeze({ + create, + update + }); +} + +function jobStatusHandler(config) { + let jobStatus; + const objectId = (0, _cryptoUtils.newObjectId)(config.objectIdSize); + const database = config.database; + const handler = statusHandler(JOB_STATUS_COLLECTION, database); + const setRunning = function (jobName, params) { + const now = new Date(); + jobStatus = { + objectId, + jobName, + params, + status: 'running', + source: 'api', + createdAt: now, + // lockdown! + ACL: {} + }; + + return handler.create(jobStatus); + }; + + const setMessage = function (message) { + if (!message || typeof message !== 'string') { + return Promise.resolve(); + } + return handler.update({ objectId }, { message }); + }; + + const setSucceeded = function (message) { + return setFinalStatus('succeeded', message); + }; + + const setFailed = function (message) { + return setFinalStatus('failed', message); + }; + + const setFinalStatus = function (status, message = undefined) { + const finishedAt = new Date(); + const update = { status, finishedAt }; + if (message && typeof message === 'string') { + update.message = message; + } + return handler.update({ objectId }, update); + }; + + return Object.freeze({ + setRunning, + setSucceeded, + setMessage, + setFailed + }); +} + +function pushStatusHandler(config, existingObjectId) { + + let pushStatus; + const database = config.database; + const handler = restStatusHandler(PUSH_STATUS_COLLECTION, config); + let objectId = existingObjectId; + const setInitial = function (body = {}, where, options = { source: 'rest' }) { + const now = new Date(); + let pushTime = now.toISOString(); + let status = 'pending'; + if (body.hasOwnProperty('push_time')) { + if (config.hasPushScheduledSupport) { + pushTime = body.push_time; + status = 'scheduled'; + } else { + _logger.logger.warn('Trying to schedule a push while server is not configured.'); + _logger.logger.warn('Push will be sent immediately'); + } + } + + const data = body.data || {}; + const payloadString = JSON.stringify(data); + let pushHash; + if (typeof data.alert === 'string') { + pushHash = (0, _cryptoUtils.md5Hash)(data.alert); + } else if (typeof data.alert === 'object') { + pushHash = (0, _cryptoUtils.md5Hash)(JSON.stringify(data.alert)); + } else { + pushHash = 'd41d8cd98f00b204e9800998ecf8427e'; + } + const object = { + pushTime, + query: JSON.stringify(where), + payload: payloadString, + source: options.source, + title: options.title, + expiry: body.expiration_time, + expiration_interval: body.expiration_interval, + status: status, + numSent: 0, + pushHash, + // lockdown! + ACL: {} + }; + return handler.create(object).then(result => { + objectId = result.objectId; + pushStatus = { + objectId + }; + return Promise.resolve(pushStatus); + }); + }; + + const setRunning = function (batches) { + _logger.logger.verbose(`_PushStatus ${objectId}: sending push to installations with %d batches`, batches); + return handler.update({ + status: "pending", + objectId: objectId + }, { + status: "running", + count: batches + }); + }; + + const trackSent = function (results, UTCOffset, cleanupInstallations = process.env.PARSE_SERVER_CLEANUP_INVALID_INSTALLATIONS) { + const update = { + numSent: 0, + numFailed: 0 + }; + const devicesToRemove = []; + if (Array.isArray(results)) { + results = flatten(results); + results.reduce((memo, result) => { + // Cannot handle that + if (!result || !result.device || !result.device.deviceType) { + return memo; + } + const deviceType = result.device.deviceType; + const key = result.transmitted ? `sentPerType.${deviceType}` : `failedPerType.${deviceType}`; + memo[key] = incrementOp(memo, key); + if (typeof UTCOffset !== 'undefined') { + const offsetKey = result.transmitted ? `sentPerUTCOffset.${UTCOffset}` : `failedPerUTCOffset.${UTCOffset}`; + memo[offsetKey] = incrementOp(memo, offsetKey); + } + if (result.transmitted) { + memo.numSent++; + } else { + if (result && result.response && result.response.error && result.device && result.device.deviceToken) { + const token = result.device.deviceToken; + const error = result.response.error; + // GCM errors + if (error === 'NotRegistered' || error === 'InvalidRegistration') { + devicesToRemove.push(token); + } + // APNS errors + if (error === 'Unregistered' || error === 'BadDeviceToken') { + devicesToRemove.push(token); + } + } + memo.numFailed++; + } + return memo; + }, update); + } + + _logger.logger.verbose(`_PushStatus ${objectId}: sent push! %d success, %d failures`, update.numSent, update.numFailed); + _logger.logger.verbose(`_PushStatus ${objectId}: needs cleanup`, { devicesToRemove }); + ['numSent', 'numFailed'].forEach(key => { + if (update[key] > 0) { + update[key] = { + __op: 'Increment', + amount: update[key] + }; + } else { + delete update[key]; + } + }); + + if (devicesToRemove.length > 0 && cleanupInstallations) { + _logger.logger.info(`Removing device tokens on ${devicesToRemove.length} _Installations`); + database.update('_Installation', { deviceToken: { '$in': devicesToRemove } }, { deviceToken: { "__op": "Delete" } }, { + acl: undefined, + many: true + }); + } + + // indicate this batch is complete + incrementOp(update, 'count', -1); + + return handler.update({ objectId }, update).then(res => { + if (res && res.count === 0) { + return this.complete(); + } + }); + }; + + const complete = function () { + return handler.update({ objectId }, { + status: 'succeeded', + count: { __op: 'Delete' } + }); + }; + + const fail = function (err) { + if (typeof err === 'string') { + err = { message: err }; + } + const update = { + errorMessage: err, + status: 'failed' + }; + return handler.update({ objectId }, update); + }; + + const rval = { + setInitial, + setRunning, + trackSent, + complete, + fail + }; + + // define objectId to be dynamic + Object.defineProperty(rval, "objectId", { + get: () => objectId + }); + + return Object.freeze(rval); +} \ No newline at end of file diff --git a/lib/TestUtils.js b/lib/TestUtils.js new file mode 100644 index 0000000000..df58b7ceca --- /dev/null +++ b/lib/TestUtils.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.destroyAllDataPermanently = destroyAllDataPermanently; + +var _cache = require('./cache'); + +var _cache2 = _interopRequireDefault(_cache); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +//Used by tests +function destroyAllDataPermanently() { + if (!process.env.TESTING) { + throw 'Only supported in test environment'; + } + return Promise.all(Object.keys(_cache2.default.cache).map(appId => { + const app = _cache2.default.get(appId); + if (app.databaseController) { + return app.databaseController.deleteEverything(); + } else { + return Promise.resolve(); + } + })); +} \ No newline at end of file diff --git a/lib/batch.js b/lib/batch.js new file mode 100644 index 0000000000..1d95e529c0 --- /dev/null +++ b/lib/batch.js @@ -0,0 +1,98 @@ +'use strict'; + +const Parse = require('parse/node').Parse; +const url = require('url'); +const path = require('path'); +// These methods handle batch requests. +const batchPath = '/batch'; + +// Mounts a batch-handler onto a PromiseRouter. +function mountOnto(router) { + router.route('POST', batchPath, req => { + return handleBatch(router, req); + }); +} + +function parseURL(URL) { + if (typeof URL === 'string') { + return url.parse(URL); + } + return undefined; +} + +function makeBatchRoutingPathFunction(originalUrl, serverURL, publicServerURL) { + serverURL = serverURL ? parseURL(serverURL) : undefined; + publicServerURL = publicServerURL ? parseURL(publicServerURL) : undefined; + + const apiPrefixLength = originalUrl.length - batchPath.length; + let apiPrefix = originalUrl.slice(0, apiPrefixLength); + + const makeRoutablePath = function (requestPath) { + // The routablePath is the path minus the api prefix + if (requestPath.slice(0, apiPrefix.length) != apiPrefix) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot route batch path ' + requestPath); + } + return path.posix.join('/', requestPath.slice(apiPrefix.length)); + }; + + if (serverURL && publicServerURL && serverURL.path != publicServerURL.path) { + const localPath = serverURL.path; + const publicPath = publicServerURL.path; + // Override the api prefix + apiPrefix = localPath; + return function (requestPath) { + // Build the new path by removing the public path + // and joining with the local path + const newPath = path.posix.join('/', localPath, '/', requestPath.slice(publicPath.length)); + // Use the method for local routing + return makeRoutablePath(newPath); + }; + } + + return makeRoutablePath; +} + +// Returns a promise for a {response} object. +// TODO: pass along auth correctly +function handleBatch(router, req) { + if (!Array.isArray(req.body.requests)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'requests must be an array'); + } + + // The batch paths are all from the root of our domain. + // That means they include the API prefix, that the API is mounted + // to. However, our promise router does not route the api prefix. So + // we need to figure out the API prefix, so that we can strip it + // from all the subrequests. + if (!req.originalUrl.endsWith(batchPath)) { + throw 'internal routing problem - expected url to end with batch'; + } + + const makeRoutablePath = makeBatchRoutingPathFunction(req.originalUrl, req.config.serverURL, req.config.publicServerURL); + + const promises = req.body.requests.map(restRequest => { + const routablePath = makeRoutablePath(restRequest.path); + // Construct a request that we can send to a handler + const request = { + body: restRequest.body, + config: req.config, + auth: req.auth, + info: req.info + }; + + return router.tryRouteRequest(restRequest.method, routablePath, request).then(response => { + return { success: response.response }; + }, error => { + return { error: { code: error.code, error: error.message } }; + }); + }); + + return Promise.all(promises).then(results => { + return { response: results }; + }); +} + +module.exports = { + mountOnto, + makeBatchRoutingPathFunction +}; \ No newline at end of file diff --git a/lib/cache.js b/lib/cache.js new file mode 100644 index 0000000000..51641150c3 --- /dev/null +++ b/lib/cache.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.AppCache = undefined; + +var _InMemoryCache = require('./Adapters/Cache/InMemoryCache'); + +var AppCache = exports.AppCache = new _InMemoryCache.InMemoryCache({ ttl: NaN }); +exports.default = AppCache; \ No newline at end of file diff --git a/lib/cli/definitions/parse-live-query-server.js b/lib/cli/definitions/parse-live-query-server.js new file mode 100644 index 0000000000..094e37ca72 --- /dev/null +++ b/lib/cli/definitions/parse-live-query-server.js @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +const LiveQueryServerOptions = require('../../Options/Definitions').LiveQueryServerOptions; +exports.default = LiveQueryServerOptions; \ No newline at end of file diff --git a/lib/cli/definitions/parse-server.js b/lib/cli/definitions/parse-server.js new file mode 100644 index 0000000000..f9dbfe85ac --- /dev/null +++ b/lib/cli/definitions/parse-server.js @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +const ParseServerDefinitions = require('../../Options/Definitions').ParseServerOptions; +exports.default = ParseServerDefinitions; \ No newline at end of file diff --git a/lib/cli/parse-live-query-server.js b/lib/cli/parse-live-query-server.js new file mode 100644 index 0000000000..4adcd0ea43 --- /dev/null +++ b/lib/cli/parse-live-query-server.js @@ -0,0 +1,21 @@ +'use strict'; + +var _parseLiveQueryServer = require('./definitions/parse-live-query-server'); + +var _parseLiveQueryServer2 = _interopRequireDefault(_parseLiveQueryServer); + +var _runner = require('./utils/runner'); + +var _runner2 = _interopRequireDefault(_runner); + +var _index = require('../index'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +(0, _runner2.default)({ + definitions: _parseLiveQueryServer2.default, + start: function (program, options, logOptions) { + logOptions(); + _index.ParseServer.createLiveQueryServer(undefined, options); + } +}); \ No newline at end of file diff --git a/lib/cli/parse-server.js b/lib/cli/parse-server.js new file mode 100755 index 0000000000..125396c70c --- /dev/null +++ b/lib/cli/parse-server.js @@ -0,0 +1,98 @@ +'use strict'; + +var _index = require('../index'); + +var _index2 = _interopRequireDefault(_index); + +var _parseServer = require('./definitions/parse-server'); + +var _parseServer2 = _interopRequireDefault(_parseServer); + +var _cluster = require('cluster'); + +var _cluster2 = _interopRequireDefault(_cluster); + +var _os = require('os'); + +var _os2 = _interopRequireDefault(_os); + +var _runner = require('./utils/runner'); + +var _runner2 = _interopRequireDefault(_runner); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const help = function () { + console.log(' Get Started guide:'); + console.log(''); + console.log(' Please have a look at the get started guide!'); + console.log(' http://docs.parseplatform.org/parse-server/guide/'); + console.log(''); + console.log(''); + console.log(' Usage with npm start'); + console.log(''); + console.log(' $ npm start -- path/to/config.json'); + console.log(' $ npm start -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL'); + console.log(' $ npm start -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL'); + console.log(''); + console.log(''); + console.log(' Usage:'); + console.log(''); + console.log(' $ parse-server path/to/config.json'); + console.log(' $ parse-server -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL'); + console.log(' $ parse-server -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL'); + console.log(''); +}; /* eslint-disable no-console */ + + +(0, _runner2.default)({ + definitions: _parseServer2.default, + help, + usage: '[options] ', + start: function (program, options, logOptions) { + if (!options.appId || !options.masterKey) { + program.outputHelp(); + console.error(""); + console.error('\u001b[31mERROR: appId and masterKey are required\u001b[0m'); + console.error(""); + process.exit(1); + } + + if (options["liveQuery.classNames"]) { + options.liveQuery = options.liveQuery || {}; + options.liveQuery.classNames = options["liveQuery.classNames"]; + delete options["liveQuery.classNames"]; + } + if (options["liveQuery.redisURL"]) { + options.liveQuery = options.liveQuery || {}; + options.liveQuery.redisURL = options["liveQuery.redisURL"]; + delete options["liveQuery.redisURL"]; + } + + if (options.cluster) { + const numCPUs = typeof options.cluster === 'number' ? options.cluster : _os2.default.cpus().length; + if (_cluster2.default.isMaster) { + logOptions(); + for (let i = 0; i < numCPUs; i++) { + _cluster2.default.fork(); + } + _cluster2.default.on('exit', (worker, code) => { + console.log(`worker ${worker.process.pid} died (${code})... Restarting`); + _cluster2.default.fork(); + }); + } else { + _index2.default.start(options, () => { + console.log('[' + process.pid + '] parse-server running on ' + options.serverURL); + }); + } + } else { + _index2.default.start(options, () => { + logOptions(); + console.log(''); + console.log('[' + process.pid + '] parse-server running on ' + options.serverURL); + }); + } + } +}); + +/* eslint-enable no-console */ \ No newline at end of file diff --git a/lib/cli/utils/commander.js b/lib/cli/utils/commander.js new file mode 100644 index 0000000000..3059e45614 --- /dev/null +++ b/lib/cli/utils/commander.js @@ -0,0 +1,140 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _commander = require('commander'); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/* eslint-disable no-console */ +let _definitions; +let _reverseDefinitions; +let _defaults; + +_commander.Command.prototype.loadDefinitions = function (definitions) { + _definitions = definitions; + + Object.keys(definitions).reduce((program, opt) => { + if (typeof definitions[opt] == "object") { + const additionalOptions = definitions[opt]; + if (additionalOptions.required === true) { + return program.option(`--${opt} <${opt}>`, additionalOptions.help, additionalOptions.action); + } else { + return program.option(`--${opt} [${opt}]`, additionalOptions.help, additionalOptions.action); + } + } + return program.option(`--${opt} [${opt}]`); + }, this); + + _reverseDefinitions = Object.keys(definitions).reduce((object, key) => { + let value = definitions[key]; + if (typeof value == "object") { + value = value.env; + } + if (value) { + object[value] = key; + } + return object; + }, {}); + + _defaults = Object.keys(definitions).reduce((defs, opt) => { + if (_definitions[opt].default) { + defs[opt] = _definitions[opt].default; + } + return defs; + }, {}); + + /* istanbul ignore next */ + this.on('--help', function () { + console.log(' Configure From Environment:'); + console.log(''); + Object.keys(_reverseDefinitions).forEach(key => { + console.log(` $ ${key}='${_reverseDefinitions[key]}'`); + }); + console.log(''); + }); +}; + +function parseEnvironment(env = {}) { + return Object.keys(_reverseDefinitions).reduce((options, key) => { + if (env[key]) { + const originalKey = _reverseDefinitions[key]; + let action = option => option; + if (typeof _definitions[originalKey] === "object") { + action = _definitions[originalKey].action || action; + } + options[_reverseDefinitions[key]] = action(env[key]); + } + return options; + }, {}); +} + +function parseConfigFile(program) { + let options = {}; + if (program.args.length > 0) { + let jsonPath = program.args[0]; + jsonPath = _path2.default.resolve(jsonPath); + const jsonConfig = require(jsonPath); + if (jsonConfig.apps) { + if (jsonConfig.apps.length > 1) { + throw 'Multiple apps are not supported'; + } + options = jsonConfig.apps[0]; + } else { + options = jsonConfig; + } + Object.keys(options).forEach(key => { + const value = options[key]; + if (!_definitions[key]) { + throw `error: unknown option ${key}`; + } + const action = _definitions[key].action; + if (action) { + options[key] = action(value); + } + }); + console.log(`Configuration loaded from ${jsonPath}`); + } + return options; +} + +_commander.Command.prototype.setValuesIfNeeded = function (options) { + Object.keys(options).forEach(key => { + if (!this.hasOwnProperty(key)) { + this[key] = options[key]; + } + }); +}; + +_commander.Command.prototype._parse = _commander.Command.prototype.parse; + +_commander.Command.prototype.parse = function (args, env) { + this._parse(args); + // Parse the environment first + const envOptions = parseEnvironment(env); + const fromFile = parseConfigFile(this); + // Load the env if not passed from command line + this.setValuesIfNeeded(envOptions); + // Load from file to override + this.setValuesIfNeeded(fromFile); + // Last set the defaults + this.setValuesIfNeeded(_defaults); +}; + +_commander.Command.prototype.getOptions = function () { + return Object.keys(_definitions).reduce((options, key) => { + if (typeof this[key] !== 'undefined') { + options[key] = this[key]; + } + return options; + }, {}); +}; + +exports.default = new _commander.Command(); +/* eslint-enable no-console */ \ No newline at end of file diff --git a/lib/cli/utils/runner.js b/lib/cli/utils/runner.js new file mode 100644 index 0000000000..0f38ab9e2e --- /dev/null +++ b/lib/cli/utils/runner.js @@ -0,0 +1,53 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +exports.default = function ({ + definitions, + help, + usage, + start +}) { + _commander2.default.loadDefinitions(definitions); + if (usage) { + _commander2.default.usage(usage); + } + if (help) { + _commander2.default.on('--help', help); + } + _commander2.default.parse(process.argv, process.env); + + const options = _commander2.default.getOptions(); + start(_commander2.default, options, function () { + logStartupOptions(options); + }); +}; + +var _commander = require("./commander"); + +var _commander2 = _interopRequireDefault(_commander); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function logStartupOptions(options) { + for (const key in options) { + let value = options[key]; + if (key == "masterKey") { + value = "***REDACTED***"; + } + if (typeof value === 'object') { + try { + value = JSON.stringify(value); + } catch (e) { + if (value && value.constructor && value.constructor.name) { + value = value.constructor.name; + } + } + } + /* eslint-disable no-console */ + console.log(`${key}: ${value}`); + /* eslint-enable no-console */ + } +} \ No newline at end of file diff --git a/lib/cloud-code/HTTPResponse.js b/lib/cloud-code/HTTPResponse.js new file mode 100644 index 0000000000..47fd6e9d44 --- /dev/null +++ b/lib/cloud-code/HTTPResponse.js @@ -0,0 +1,56 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +class HTTPResponse { + constructor(response, body) { + let _text, _data; + this.status = response.statusCode; + this.headers = response.headers || {}; + this.cookies = this.headers["set-cookie"]; + + if (typeof body == 'string') { + _text = body; + } else if (Buffer.isBuffer(body)) { + this.buffer = body; + } else if (typeof body == 'object') { + _data = body; + } + + const getText = () => { + if (!_text && this.buffer) { + _text = this.buffer.toString('utf-8'); + } else if (!_text && _data) { + _text = JSON.stringify(_data); + } + return _text; + }; + + const getData = () => { + if (!_data) { + try { + _data = JSON.parse(getText()); + } catch (e) {/* */} + } + return _data; + }; + + Object.defineProperty(this, 'body', { + get: () => { + return body; + } + }); + + Object.defineProperty(this, 'text', { + enumerable: true, + get: getText + }); + + Object.defineProperty(this, 'data', { + enumerable: true, + get: getData + }); + } +} +exports.default = HTTPResponse; \ No newline at end of file diff --git a/lib/cloud-code/Parse.Cloud.js b/lib/cloud-code/Parse.Cloud.js new file mode 100644 index 0000000000..f33baa9116 --- /dev/null +++ b/lib/cloud-code/Parse.Cloud.js @@ -0,0 +1,72 @@ +'use strict'; + +var _node = require('parse/node'); + +var _triggers = require('../triggers'); + +var triggers = _interopRequireWildcard(_triggers); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function getClassName(parseClass) { + if (parseClass && parseClass.className) { + return parseClass.className; + } + return parseClass; +} + +var ParseCloud = {}; +ParseCloud.define = function (functionName, handler, validationHandler) { + triggers.addFunction(functionName, handler, validationHandler, _node.Parse.applicationId); +}; + +ParseCloud.job = function (functionName, handler) { + triggers.addJob(functionName, handler, _node.Parse.applicationId); +}; + +ParseCloud.beforeSave = function (parseClass, handler) { + var className = getClassName(parseClass); + triggers.addTrigger(triggers.Types.beforeSave, className, handler, _node.Parse.applicationId); +}; + +ParseCloud.beforeDelete = function (parseClass, handler) { + var className = getClassName(parseClass); + triggers.addTrigger(triggers.Types.beforeDelete, className, handler, _node.Parse.applicationId); +}; + +ParseCloud.afterSave = function (parseClass, handler) { + var className = getClassName(parseClass); + triggers.addTrigger(triggers.Types.afterSave, className, handler, _node.Parse.applicationId); +}; + +ParseCloud.afterDelete = function (parseClass, handler) { + var className = getClassName(parseClass); + triggers.addTrigger(triggers.Types.afterDelete, className, handler, _node.Parse.applicationId); +}; + +ParseCloud.beforeFind = function (parseClass, handler) { + var className = getClassName(parseClass); + triggers.addTrigger(triggers.Types.beforeFind, className, handler, _node.Parse.applicationId); +}; + +ParseCloud.afterFind = function (parseClass, handler) { + const className = getClassName(parseClass); + triggers.addTrigger(triggers.Types.afterFind, className, handler, _node.Parse.applicationId); +}; + +ParseCloud.onLiveQueryEvent = function (handler) { + triggers.addLiveQueryEventHandler(handler, _node.Parse.applicationId); +}; + +ParseCloud._removeAllHooks = () => { + triggers._unregisterAll(); +}; + +ParseCloud.useMasterKey = () => { + // eslint-disable-next-line + console.warn("Parse.Cloud.useMasterKey is deprecated (and has no effect anymore) on parse-server, please refer to the cloud code migration notes: http://docs.parseplatform.org/parse-server/guide/#master-key-must-be-passed-explicitly"); +}; + +ParseCloud.httpRequest = require("./httpRequest"); + +module.exports = ParseCloud; \ No newline at end of file diff --git a/lib/cloud-code/httpRequest.js b/lib/cloud-code/httpRequest.js new file mode 100644 index 0000000000..64188f20dc --- /dev/null +++ b/lib/cloud-code/httpRequest.js @@ -0,0 +1,101 @@ +'use strict'; + +var _request = require('request'); + +var _request2 = _interopRequireDefault(_request); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _HTTPResponse = require('./HTTPResponse'); + +var _HTTPResponse2 = _interopRequireDefault(_HTTPResponse); + +var _querystring = require('querystring'); + +var _querystring2 = _interopRequireDefault(_querystring); + +var _logger = require('../logger'); + +var _logger2 = _interopRequireDefault(_logger); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var encodeBody = function ({ body, headers = {} }) { + if (typeof body !== 'object') { + return { body, headers }; + } + var contentTypeKeys = Object.keys(headers).filter(key => { + return key.match(/content-type/i) != null; + }); + + if (contentTypeKeys.length == 0) { + // no content type + // As per https://parse.com/docs/cloudcode/guide#cloud-code-advanced-sending-a-post-request the default encoding is supposedly x-www-form-urlencoded + + body = _querystring2.default.stringify(body); + headers['Content-Type'] = 'application/x-www-form-urlencoded'; + } else { + /* istanbul ignore next */ + if (contentTypeKeys.length > 1) { + _logger2.default.error('Parse.Cloud.httpRequest', 'multiple content-type headers are set.'); + } + // There maybe many, we'll just take the 1st one + var contentType = contentTypeKeys[0]; + if (headers[contentType].match(/application\/json/i)) { + body = JSON.stringify(body); + } else if (headers[contentType].match(/application\/x-www-form-urlencoded/i)) { + body = _querystring2.default.stringify(body); + } + } + return { body, headers }; +}; + +module.exports = function (options) { + var promise = new _node2.default.Promise(); + var callbacks = { + success: options.success, + error: options.error + }; + delete options.success; + delete options.error; + delete options.uri; // not supported + options = Object.assign(options, encodeBody(options)); + // set follow redirects to false by default + options.followRedirect = options.followRedirects == true; + // support params options + if (typeof options.params === 'object') { + options.qs = options.params; + } else if (typeof options.params === 'string') { + options.qs = _querystring2.default.parse(options.params); + } + // force the response as a buffer + options.encoding = null; + + (0, _request2.default)(options, (error, response, body) => { + if (error) { + if (callbacks.error) { + callbacks.error(error); + } + return promise.reject(error); + } + const httpResponse = new _HTTPResponse2.default(response, body); + + // Consider <200 && >= 400 as errors + if (httpResponse.status < 200 || httpResponse.status >= 400) { + if (callbacks.error) { + callbacks.error(httpResponse); + } + return promise.reject(httpResponse); + } else { + if (callbacks.success) { + callbacks.success(httpResponse); + } + return promise.resolve(httpResponse); + } + }); + return promise; +}; + +module.exports.encodeBody = encodeBody; \ No newline at end of file diff --git a/lib/cryptoUtils.js b/lib/cryptoUtils.js new file mode 100644 index 0000000000..1eae0aab4c --- /dev/null +++ b/lib/cryptoUtils.js @@ -0,0 +1,58 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.randomHexString = randomHexString; +exports.randomString = randomString; +exports.newObjectId = newObjectId; +exports.newToken = newToken; +exports.md5Hash = md5Hash; + +var _crypto = require('crypto'); + +// Returns a new random hex string of the given even size. +function randomHexString(size) { + if (size === 0) { + throw new Error('Zero-length randomHexString is useless.'); + } + if (size % 2 !== 0) { + throw new Error('randomHexString size must be divisible by 2.'); + } + return (0, _crypto.randomBytes)(size / 2).toString('hex'); +} + +// Returns a new random alphanumeric string of the given size. +// +// Note: to simplify implementation, the result has slight modulo bias, +// because chars length of 62 doesn't divide the number of all bytes +// (256) evenly. Such bias is acceptable for most cases when the output +// length is long enough and doesn't need to be uniform. + + +function randomString(size) { + if (size === 0) { + throw new Error('Zero-length randomString is useless.'); + } + const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789'; + let objectId = ''; + const bytes = (0, _crypto.randomBytes)(size); + for (let i = 0; i < bytes.length; ++i) { + objectId += chars[bytes.readUInt8(i) % chars.length]; + } + return objectId; +} + +// Returns a new random alphanumeric string suitable for object ID. +function newObjectId(size = 10) { + return randomString(size); +} + +// Returns a new random hex string suitable for secure tokens. +function newToken() { + return randomHexString(32); +} + +function md5Hash(string) { + return (0, _crypto.createHash)('md5').update(string).digest('hex'); +} \ No newline at end of file diff --git a/lib/defaults.js b/lib/defaults.js new file mode 100644 index 0000000000..2fadaeaee0 --- /dev/null +++ b/lib/defaults.js @@ -0,0 +1,43 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.DefaultMongoURI = undefined; + +var _parsers = require('./Options/parsers'); + +const { ParseServerOptions } = require('./Options/Definitions'); +const logsFolder = (() => { + let folder = './logs/'; + if (typeof process !== 'undefined' && process.env.TESTING === '1') { + folder = './test_logs/'; + } + if (process.env.PARSE_SERVER_LOGS_FOLDER) { + folder = (0, _parsers.nullParser)(process.env.PARSE_SERVER_LOGS_FOLDER); + } + return folder; +})(); + +const { verbose, level } = (() => { + const verbose = process.env.VERBOSE ? true : false; + return { verbose, level: verbose ? 'verbose' : undefined }; +})(); + +const DefinitionDefaults = Object.keys(ParseServerOptions).reduce((memo, key) => { + const def = ParseServerOptions[key]; + if (def.hasOwnProperty('default')) { + memo[key] = def.default; + } + return memo; +}, {}); + +const computedDefaults = { + jsonLogs: process.env.JSON_LOGS || false, + logsFolder, + verbose, + level +}; + +exports.default = Object.assign({}, DefinitionDefaults, computedDefaults); +const DefaultMongoURI = exports.DefaultMongoURI = DefinitionDefaults.databaseURI; \ No newline at end of file diff --git a/lib/deprecated.js b/lib/deprecated.js new file mode 100644 index 0000000000..f808c611c6 --- /dev/null +++ b/lib/deprecated.js @@ -0,0 +1,11 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.useExternal = useExternal; +function useExternal(name, moduleName) { + return function () { + throw `${name} is not provided by parse-server anymore; please install ${moduleName}`; + }; +} \ No newline at end of file diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 0000000000..b3ba2ad882 --- /dev/null +++ b/lib/index.js @@ -0,0 +1,77 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ParseServer = exports.PushWorker = exports.TestUtils = exports.LRUCacheAdapter = exports.RedisCacheAdapter = exports.NullCacheAdapter = exports.InMemoryCacheAdapter = exports.FileSystemAdapter = exports.GCSAdapter = exports.S3Adapter = undefined; + +var _ParseServer2 = require('./ParseServer'); + +var _ParseServer3 = _interopRequireDefault(_ParseServer2); + +var _s3FilesAdapter = require('@parse/s3-files-adapter'); + +var _s3FilesAdapter2 = _interopRequireDefault(_s3FilesAdapter); + +var _fsFilesAdapter = require('@parse/fs-files-adapter'); + +var _fsFilesAdapter2 = _interopRequireDefault(_fsFilesAdapter); + +var _InMemoryCacheAdapter = require('./Adapters/Cache/InMemoryCacheAdapter'); + +var _InMemoryCacheAdapter2 = _interopRequireDefault(_InMemoryCacheAdapter); + +var _NullCacheAdapter = require('./Adapters/Cache/NullCacheAdapter'); + +var _NullCacheAdapter2 = _interopRequireDefault(_NullCacheAdapter); + +var _RedisCacheAdapter = require('./Adapters/Cache/RedisCacheAdapter'); + +var _RedisCacheAdapter2 = _interopRequireDefault(_RedisCacheAdapter); + +var _LRUCache = require('./Adapters/Cache/LRUCache.js'); + +var _LRUCache2 = _interopRequireDefault(_LRUCache); + +var _TestUtils = require('./TestUtils'); + +var TestUtils = _interopRequireWildcard(_TestUtils); + +var _deprecated = require('./deprecated'); + +var _logger = require('./logger'); + +var _PushWorker = require('./Push/PushWorker'); + +var _Options = require('./Options'); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// Factory function +const _ParseServer = function (options) { + const server = new _ParseServer3.default(options); + return server.app; +}; +// Mount the create liveQueryServer +_ParseServer.createLiveQueryServer = _ParseServer3.default.createLiveQueryServer; +_ParseServer.start = _ParseServer3.default.start; + +const GCSAdapter = (0, _deprecated.useExternal)('GCSAdapter', '@parse/gcs-files-adapter'); + +Object.defineProperty(module.exports, 'logger', { + get: _logger.getLogger +}); + +exports.default = _ParseServer3.default; +exports.S3Adapter = _s3FilesAdapter2.default; +exports.GCSAdapter = GCSAdapter; +exports.FileSystemAdapter = _fsFilesAdapter2.default; +exports.InMemoryCacheAdapter = _InMemoryCacheAdapter2.default; +exports.NullCacheAdapter = _NullCacheAdapter2.default; +exports.RedisCacheAdapter = _RedisCacheAdapter2.default; +exports.LRUCacheAdapter = _LRUCache2.default; +exports.TestUtils = TestUtils; +exports.PushWorker = _PushWorker.PushWorker; +exports.ParseServer = _ParseServer; \ No newline at end of file diff --git a/lib/logger.js b/lib/logger.js new file mode 100644 index 0000000000..1f9e6dea5e --- /dev/null +++ b/lib/logger.js @@ -0,0 +1,47 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.setLogger = setLogger; +exports.getLogger = getLogger; + +var _defaults = require('./defaults'); + +var _defaults2 = _interopRequireDefault(_defaults); + +var _WinstonLoggerAdapter = require('./Adapters/Logger/WinstonLoggerAdapter'); + +var _LoggerController = require('./Controllers/LoggerController'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function defaultLogger() { + const options = { + logsFolder: _defaults2.default.logsFolder, + jsonLogs: _defaults2.default.jsonLogs, + verbose: _defaults2.default.verbose, + silent: _defaults2.default.silent }; + const adapter = new _WinstonLoggerAdapter.WinstonLoggerAdapter(options); + return new _LoggerController.LoggerController(adapter, null, options); +} + +let logger = defaultLogger(); + +function setLogger(aLogger) { + logger = aLogger; +} + +function getLogger() { + return logger; +} + +// for: `import logger from './logger'` +Object.defineProperty(module.exports, 'default', { + get: getLogger +}); + +// for: `import { logger } from './logger'` +Object.defineProperty(module.exports, 'logger', { + get: getLogger +}); \ No newline at end of file diff --git a/lib/middlewares.js b/lib/middlewares.js new file mode 100644 index 0000000000..4b336419f7 --- /dev/null +++ b/lib/middlewares.js @@ -0,0 +1,344 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.handleParseHeaders = handleParseHeaders; +exports.allowCrossDomain = allowCrossDomain; +exports.allowMethodOverride = allowMethodOverride; +exports.handleParseErrors = handleParseErrors; +exports.enforceMasterKeyAccess = enforceMasterKeyAccess; +exports.promiseEnforceMasterKeyAccess = promiseEnforceMasterKeyAccess; + +var _cache = require('./cache'); + +var _cache2 = _interopRequireDefault(_cache); + +var _logger = require('./logger'); + +var _logger2 = _interopRequireDefault(_logger); + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _Auth = require('./Auth'); + +var _Auth2 = _interopRequireDefault(_Auth); + +var _Config = require('./Config'); + +var _Config2 = _interopRequireDefault(_Config); + +var _ClientSDK = require('./ClientSDK'); + +var _ClientSDK2 = _interopRequireDefault(_ClientSDK); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// Checks that the request is authorized for this app and checks user +// auth too. +// The bodyparser should run before this middleware. +// Adds info to the request: +// req.config - the Config for this app +// req.auth - the Auth for this request +function handleParseHeaders(req, res, next) { + var mountPathLength = req.originalUrl.length - req.url.length; + var mountPath = req.originalUrl.slice(0, mountPathLength); + var mount = req.protocol + '://' + req.get('host') + mountPath; + + var info = { + appId: req.get('X-Parse-Application-Id'), + sessionToken: req.get('X-Parse-Session-Token'), + masterKey: req.get('X-Parse-Master-Key'), + installationId: req.get('X-Parse-Installation-Id'), + clientKey: req.get('X-Parse-Client-Key'), + javascriptKey: req.get('X-Parse-Javascript-Key'), + dotNetKey: req.get('X-Parse-Windows-Key'), + restAPIKey: req.get('X-Parse-REST-API-Key'), + clientVersion: req.get('X-Parse-Client-Version') + }; + + var basicAuth = httpAuth(req); + + if (basicAuth) { + var basicAuthAppId = basicAuth.appId; + if (_cache2.default.get(basicAuthAppId)) { + info.appId = basicAuthAppId; + info.masterKey = basicAuth.masterKey || info.masterKey; + info.javascriptKey = basicAuth.javascriptKey || info.javascriptKey; + } + } + + if (req.body) { + // Unity SDK sends a _noBody key which needs to be removed. + // Unclear at this point if action needs to be taken. + delete req.body._noBody; + } + + var fileViaJSON = false; + + if (!info.appId || !_cache2.default.get(info.appId)) { + // See if we can find the app id on the body. + if (req.body instanceof Buffer) { + // The only chance to find the app id is if this is a file + // upload that actually is a JSON body. So try to parse it. + req.body = JSON.parse(req.body); + fileViaJSON = true; + } + + if (req.body) { + delete req.body._RevocableSession; + } + + if (req.body && req.body._ApplicationId && _cache2.default.get(req.body._ApplicationId) && (!info.masterKey || _cache2.default.get(req.body._ApplicationId).masterKey === info.masterKey)) { + info.appId = req.body._ApplicationId; + info.javascriptKey = req.body._JavaScriptKey || ''; + delete req.body._ApplicationId; + delete req.body._JavaScriptKey; + // TODO: test that the REST API formats generated by the other + // SDKs are handled ok + if (req.body._ClientVersion) { + info.clientVersion = req.body._ClientVersion; + delete req.body._ClientVersion; + } + if (req.body._InstallationId) { + info.installationId = req.body._InstallationId; + delete req.body._InstallationId; + } + if (req.body._SessionToken) { + info.sessionToken = req.body._SessionToken; + delete req.body._SessionToken; + } + if (req.body._MasterKey) { + info.masterKey = req.body._MasterKey; + delete req.body._MasterKey; + } + if (req.body._ContentType) { + req.headers['content-type'] = req.body._ContentType; + delete req.body._ContentType; + } + } else { + return invalidRequest(req, res); + } + } + + if (info.clientVersion) { + info.clientSDK = _ClientSDK2.default.fromString(info.clientVersion); + } + + if (fileViaJSON) { + // We need to repopulate req.body with a buffer + var base64 = req.body.base64; + req.body = new Buffer(base64, 'base64'); + } + + const clientIp = getClientIp(req); + + info.app = _cache2.default.get(info.appId); + req.config = _Config2.default.get(info.appId, mount); + req.config.headers = req.headers || {}; + req.config.ip = clientIp; + req.info = info; + + if (info.masterKey && req.config.masterKeyIps && req.config.masterKeyIps.length !== 0 && req.config.masterKeyIps.indexOf(clientIp) === -1) { + return invalidRequest(req, res); + } + + var isMaster = info.masterKey === req.config.masterKey; + + if (isMaster) { + req.auth = new _Auth2.default.Auth({ config: req.config, installationId: info.installationId, isMaster: true }); + next(); + return; + } + + var isReadOnlyMaster = info.masterKey === req.config.readOnlyMasterKey; + if (typeof req.config.readOnlyMasterKey != 'undefined' && req.config.readOnlyMasterKey && isReadOnlyMaster) { + req.auth = new _Auth2.default.Auth({ config: req.config, installationId: info.installationId, isMaster: true, isReadOnly: true }); + next(); + return; + } + + // Client keys are not required in parse-server, but if any have been configured in the server, validate them + // to preserve original behavior. + const keys = ["clientKey", "javascriptKey", "dotNetKey", "restAPIKey"]; + const oneKeyConfigured = keys.some(function (key) { + return req.config[key] !== undefined; + }); + const oneKeyMatches = keys.some(function (key) { + return req.config[key] !== undefined && info[key] === req.config[key]; + }); + + if (oneKeyConfigured && !oneKeyMatches) { + return invalidRequest(req, res); + } + + if (req.url == "/login") { + delete info.sessionToken; + } + + if (!info.sessionToken) { + req.auth = new _Auth2.default.Auth({ config: req.config, installationId: info.installationId, isMaster: false }); + next(); + return; + } + + return Promise.resolve().then(() => { + // handle the upgradeToRevocableSession path on it's own + if (info.sessionToken && req.url === '/upgradeToRevocableSession' && info.sessionToken.indexOf('r:') != 0) { + return _Auth2.default.getAuthForLegacySessionToken({ config: req.config, installationId: info.installationId, sessionToken: info.sessionToken }); + } else { + return _Auth2.default.getAuthForSessionToken({ config: req.config, installationId: info.installationId, sessionToken: info.sessionToken }); + } + }).then(auth => { + if (auth) { + req.auth = auth; + next(); + } + }).catch(error => { + if (error instanceof _node2.default.Error) { + next(error); + return; + } else { + // TODO: Determine the correct error scenario. + _logger2.default.error('error getting auth for sessionToken', error); + throw new _node2.default.Error(_node2.default.Error.UNKNOWN_ERROR, error); + } + }); +} + +function getClientIp(req) { + if (req.headers['x-forwarded-for']) { + // try to get from x-forwared-for if it set (behind reverse proxy) + return req.headers['x-forwarded-for'].split(',')[0]; + } else if (req.connection && req.connection.remoteAddress) { + // no proxy, try getting from connection.remoteAddress + return req.connection.remoteAddress; + } else if (req.socket) { + // try to get it from req.socket + return req.socket.remoteAddress; + } else if (req.connection && req.connection.socket) { + // try to get it form the connection.socket + return req.connection.socket.remoteAddress; + } else { + // if non above, fallback. + return req.ip; + } +} + +function httpAuth(req) { + if (!(req.req || req).headers.authorization) return; + + var header = (req.req || req).headers.authorization; + var appId, masterKey, javascriptKey; + + // parse header + var authPrefix = 'basic '; + + var match = header.toLowerCase().indexOf(authPrefix); + + if (match == 0) { + var encodedAuth = header.substring(authPrefix.length, header.length); + var credentials = decodeBase64(encodedAuth).split(':'); + + if (credentials.length == 2) { + appId = credentials[0]; + var key = credentials[1]; + + var jsKeyPrefix = 'javascript-key='; + + var matchKey = key.indexOf(jsKeyPrefix); + if (matchKey == 0) { + javascriptKey = key.substring(jsKeyPrefix.length, key.length); + } else { + masterKey = key; + } + } + } + + return { appId: appId, masterKey: masterKey, javascriptKey: javascriptKey }; +} + +function decodeBase64(str) { + return new Buffer(str, 'base64').toString(); +} + +function allowCrossDomain(req, res, next) { + res.header('Access-Control-Allow-Origin', '*'); + res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS'); + res.header('Access-Control-Allow-Headers', 'X-Parse-Master-Key, X-Parse-REST-API-Key, X-Parse-Javascript-Key, X-Parse-Application-Id, X-Parse-Client-Version, X-Parse-Session-Token, X-Requested-With, X-Parse-Revocable-Session, Content-Type, X-CSRF-Token'); + + // intercept OPTIONS method + if ('OPTIONS' == req.method) { + res.sendStatus(200); + } else { + next(); + } +} + +function allowMethodOverride(req, res, next) { + if (req.method === 'POST' && req.body._method) { + req.originalMethod = req.method; + req.method = req.body._method; + delete req.body._method; + } + next(); +} + +function handleParseErrors(err, req, res, next) { + if (err instanceof _node2.default.Error) { + let httpStatus; + // TODO: fill out this mapping + switch (err.code) { + case _node2.default.Error.INTERNAL_SERVER_ERROR: + httpStatus = 500; + break; + case _node2.default.Error.OBJECT_NOT_FOUND: + httpStatus = 404; + break; + default: + httpStatus = 400; + } + + res.status(httpStatus); + res.json({ code: err.code, error: err.message }); + _logger2.default.error(err.message, err); + } else if (err.status && err.message) { + res.status(err.status); + res.json({ error: err.message }); + next(err); + } else { + _logger2.default.error('Uncaught internal server error.', err, err.stack); + res.status(500); + res.json({ + code: _node2.default.Error.INTERNAL_SERVER_ERROR, + message: 'Internal server error.' + }); + next(err); + } +} + +function enforceMasterKeyAccess(req, res, next) { + if (!req.auth.isMaster) { + res.status(403); + res.end('{"error":"unauthorized: master key is required"}'); + return; + } + next(); +} + +function promiseEnforceMasterKeyAccess(request) { + if (!request.auth.isMaster) { + const error = new Error(); + error.status = 403; + error.message = "unauthorized: master key is required"; + throw error; + } + return Promise.resolve(); +} + +function invalidRequest(req, res) { + res.status(403); + res.end('{"error":"unauthorized"}'); +} \ No newline at end of file diff --git a/lib/password.js b/lib/password.js new file mode 100644 index 0000000000..729a07b272 --- /dev/null +++ b/lib/password.js @@ -0,0 +1,29 @@ +'use strict'; + +// Tools for encrypting and decrypting passwords. +// Basically promise-friendly wrappers for bcrypt. +var bcrypt = require('bcryptjs'); + +try { + bcrypt = require('bcrypt'); +} catch (e) {} /* */ + +// Returns a promise for a hashed password string. +function hash(password) { + return bcrypt.hash(password, 10); +} + +// Returns a promise for whether this password compares to equal this +// hashed password. +function compare(password, hashedPassword) { + // Cannot bcrypt compare when one is undefined + if (!password || !hashedPassword) { + return Promise.resolve(false); + } + return bcrypt.compare(password, hashedPassword); +} + +module.exports = { + hash: hash, + compare: compare +}; \ No newline at end of file diff --git a/lib/requiredParameter.js b/lib/requiredParameter.js new file mode 100644 index 0000000000..844b5a0749 --- /dev/null +++ b/lib/requiredParameter.js @@ -0,0 +1,9 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +exports.default = errorMessage => { + throw errorMessage; +}; \ No newline at end of file diff --git a/lib/rest.js b/lib/rest.js new file mode 100644 index 0000000000..ffe0e0326a --- /dev/null +++ b/lib/rest.js @@ -0,0 +1,180 @@ +'use strict'; + +var _Auth = require('./Auth'); + +var _Auth2 = _interopRequireDefault(_Auth); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// This file contains helpers for running operations in REST format. +// The goal is that handlers that explicitly handle an express route +// should just be shallow wrappers around things in this file, but +// these functions should not explicitly depend on the request +// object. +// This means that one of these handlers can support multiple +// routes. That's useful for the routes that do really similar +// things. + +var Parse = require('parse/node').Parse; + + +var RestQuery = require('./RestQuery'); +var RestWrite = require('./RestWrite'); +var triggers = require('./triggers'); + +function checkTriggers(className, config, types) { + return types.some(triggerType => { + return triggers.getTrigger(className, triggers.Types[triggerType], config.applicationId); + }); +} + +function checkLiveQuery(className, config) { + return config.liveQueryController && config.liveQueryController.hasLiveQuery(className); +} + +// Returns a promise for an object with optional keys 'results' and 'count'. +function find(config, auth, className, restWhere, restOptions, clientSDK) { + enforceRoleSecurity('find', className, auth); + return triggers.maybeRunQueryTrigger(triggers.Types.beforeFind, className, restWhere, restOptions, config, auth).then(result => { + restWhere = result.restWhere || restWhere; + restOptions = result.restOptions || restOptions; + const query = new RestQuery(config, auth, className, restWhere, restOptions, clientSDK); + return query.execute(); + }); +} + +// get is just like find but only queries an objectId. +const get = (config, auth, className, objectId, restOptions, clientSDK) => { + var restWhere = { objectId }; + enforceRoleSecurity('get', className, auth); + return triggers.maybeRunQueryTrigger(triggers.Types.beforeFind, className, restWhere, restOptions, config, auth, true).then(result => { + restWhere = result.restWhere || restWhere; + restOptions = result.restOptions || restOptions; + const query = new RestQuery(config, auth, className, restWhere, restOptions, clientSDK); + return query.execute(); + }); +}; + +// Returns a promise that doesn't resolve to any useful value. +function del(config, auth, className, objectId) { + if (typeof objectId !== 'string') { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad objectId'); + } + + if (className === '_User' && !auth.couldUpdateUserId(objectId)) { + throw new Parse.Error(Parse.Error.SESSION_MISSING, 'insufficient auth to delete user'); + } + + enforceRoleSecurity('delete', className, auth); + + var inflatedObject; + + return Promise.resolve().then(() => { + const hasTriggers = checkTriggers(className, config, ['beforeDelete', 'afterDelete']); + const hasLiveQuery = checkLiveQuery(className, config); + if (hasTriggers || hasLiveQuery || className == '_Session') { + return find(config, _Auth2.default.master(config), className, { objectId: objectId }).then(response => { + if (response && response.results && response.results.length) { + const firstResult = response.results[0]; + firstResult.className = className; + if (className === '_Session' && !auth.isMaster) { + if (!auth.user || firstResult.user.objectId !== auth.user.id) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + } + } + var cacheAdapter = config.cacheController; + cacheAdapter.user.del(firstResult.sessionToken); + inflatedObject = Parse.Object.fromJSON(firstResult); + // Notify LiveQuery server if possible + config.liveQueryController.onAfterDelete(inflatedObject.className, inflatedObject); + return triggers.maybeRunTrigger(triggers.Types.beforeDelete, auth, inflatedObject, null, config); + } + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found for delete.'); + }); + } + return Promise.resolve({}); + }).then(() => { + if (!auth.isMaster) { + return auth.getUserRoles(); + } else { + return; + } + }).then(() => { + var options = {}; + if (!auth.isMaster) { + options.acl = ['*']; + if (auth.user) { + options.acl.push(auth.user.id); + options.acl = options.acl.concat(auth.userRoles); + } + } + + return config.database.destroy(className, { + objectId: objectId + }, options); + }).then(() => { + return triggers.maybeRunTrigger(triggers.Types.afterDelete, auth, inflatedObject, null, config); + }); +} + +// Returns a promise for a {response, status, location} object. +function create(config, auth, className, restObject, clientSDK, options) { + enforceRoleSecurity('create', className, auth); + var write = new RestWrite(config, auth, className, null, restObject, null, clientSDK, options); + return write.execute(); +} + +// Returns a promise that contains the fields of the update that the +// REST API is supposed to return. +// Usually, this is just updatedAt. +function update(config, auth, className, restWhere, restObject, clientSDK) { + enforceRoleSecurity('update', className, auth); + + return Promise.resolve().then(() => { + const hasTriggers = checkTriggers(className, config, ['beforeSave', 'afterSave']); + const hasLiveQuery = checkLiveQuery(className, config); + if (hasTriggers || hasLiveQuery) { + return find(config, _Auth2.default.master(config), className, restWhere); + } + return Promise.resolve({}); + }).then(response => { + var originalRestObject; + if (response && response.results && response.results.length) { + originalRestObject = response.results[0]; + } + + var write = new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK); + return write.execute(); + }); +} + +const classesWithMasterOnlyAccess = ['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule']; +// Disallowing access to the _Role collection except by master key +function enforceRoleSecurity(method, className, auth) { + if (className === '_Installation' && !auth.isMaster) { + if (method === 'delete' || method === 'find') { + const error = `Clients aren't allowed to perform the ${method} operation on the installation collection.`; + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error); + } + } + + //all volatileClasses are masterKey only + if (classesWithMasterOnlyAccess.indexOf(className) >= 0 && !auth.isMaster) { + const error = `Clients aren't allowed to perform the ${method} operation on the ${className} collection.`; + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error); + } + + // readOnly masterKey is not allowed + if (auth.isReadOnly && (method === 'delete' || method === 'create' || method === 'update')) { + const error = `read-only masterKey isn't allowed to perform the ${method} operation.`; + throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error); + } +} + +module.exports = { + create, + del, + find, + get, + update +}; \ No newline at end of file diff --git a/lib/triggers.js b/lib/triggers.js new file mode 100644 index 0000000000..8c3ca80db8 --- /dev/null +++ b/lib/triggers.js @@ -0,0 +1,467 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Types = undefined; +exports.addFunction = addFunction; +exports.addJob = addJob; +exports.addTrigger = addTrigger; +exports.addLiveQueryEventHandler = addLiveQueryEventHandler; +exports.removeFunction = removeFunction; +exports.removeTrigger = removeTrigger; +exports._unregisterAll = _unregisterAll; +exports.getTrigger = getTrigger; +exports.triggerExists = triggerExists; +exports.getFunction = getFunction; +exports.getJob = getJob; +exports.getJobs = getJobs; +exports.getValidator = getValidator; +exports.getRequestObject = getRequestObject; +exports.getRequestQueryObject = getRequestQueryObject; +exports.getResponseObject = getResponseObject; +exports.maybeRunAfterFindTrigger = maybeRunAfterFindTrigger; +exports.maybeRunQueryTrigger = maybeRunQueryTrigger; +exports.maybeRunTrigger = maybeRunTrigger; +exports.inflate = inflate; +exports.runLiveQueryEventHandlers = runLiveQueryEventHandlers; + +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + +var _logger = require('./logger'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// triggers.js +const Types = exports.Types = { + beforeSave: 'beforeSave', + afterSave: 'afterSave', + beforeDelete: 'beforeDelete', + afterDelete: 'afterDelete', + beforeFind: 'beforeFind', + afterFind: 'afterFind' +}; + +const baseStore = function () { + const Validators = {}; + const Functions = {}; + const Jobs = {}; + const LiveQuery = []; + const Triggers = Object.keys(Types).reduce(function (base, key) { + base[key] = {}; + return base; + }, {}); + + return Object.freeze({ + Functions, + Jobs, + Validators, + Triggers, + LiveQuery + }); +}; + +function validateClassNameForTriggers(className, type) { + const restrictedClassNames = ['_Session']; + if (restrictedClassNames.indexOf(className) != -1) { + throw `Triggers are not supported for ${className} class.`; + } + if (type == Types.beforeSave && className === '_PushStatus') { + // _PushStatus uses undocumented nested key increment ops + // allowing beforeSave would mess up the objects big time + // TODO: Allow proper documented way of using nested increment ops + throw 'Only afterSave is allowed on _PushStatus'; + } + return className; +} + +const _triggerStore = {}; + +function addFunction(functionName, handler, validationHandler, applicationId) { + applicationId = applicationId || _node2.default.applicationId; + _triggerStore[applicationId] = _triggerStore[applicationId] || baseStore(); + _triggerStore[applicationId].Functions[functionName] = handler; + _triggerStore[applicationId].Validators[functionName] = validationHandler; +} + +function addJob(jobName, handler, applicationId) { + applicationId = applicationId || _node2.default.applicationId; + _triggerStore[applicationId] = _triggerStore[applicationId] || baseStore(); + _triggerStore[applicationId].Jobs[jobName] = handler; +} + +function addTrigger(type, className, handler, applicationId) { + validateClassNameForTriggers(className, type); + applicationId = applicationId || _node2.default.applicationId; + _triggerStore[applicationId] = _triggerStore[applicationId] || baseStore(); + _triggerStore[applicationId].Triggers[type][className] = handler; +} + +function addLiveQueryEventHandler(handler, applicationId) { + applicationId = applicationId || _node2.default.applicationId; + _triggerStore[applicationId] = _triggerStore[applicationId] || baseStore(); + _triggerStore[applicationId].LiveQuery.push(handler); +} + +function removeFunction(functionName, applicationId) { + applicationId = applicationId || _node2.default.applicationId; + delete _triggerStore[applicationId].Functions[functionName]; +} + +function removeTrigger(type, className, applicationId) { + applicationId = applicationId || _node2.default.applicationId; + delete _triggerStore[applicationId].Triggers[type][className]; +} + +function _unregisterAll() { + Object.keys(_triggerStore).forEach(appId => delete _triggerStore[appId]); +} + +function getTrigger(className, triggerType, applicationId) { + if (!applicationId) { + throw "Missing ApplicationID"; + } + var manager = _triggerStore[applicationId]; + if (manager && manager.Triggers && manager.Triggers[triggerType] && manager.Triggers[triggerType][className]) { + return manager.Triggers[triggerType][className]; + } + return undefined; +} + +function triggerExists(className, type, applicationId) { + return getTrigger(className, type, applicationId) != undefined; +} + +function getFunction(functionName, applicationId) { + var manager = _triggerStore[applicationId]; + if (manager && manager.Functions) { + return manager.Functions[functionName]; + } + return undefined; +} + +function getJob(jobName, applicationId) { + var manager = _triggerStore[applicationId]; + if (manager && manager.Jobs) { + return manager.Jobs[jobName]; + } + return undefined; +} + +function getJobs(applicationId) { + var manager = _triggerStore[applicationId]; + if (manager && manager.Jobs) { + return manager.Jobs; + } + return undefined; +} + +function getValidator(functionName, applicationId) { + var manager = _triggerStore[applicationId]; + if (manager && manager.Validators) { + return manager.Validators[functionName]; + } + return undefined; +} + +function getRequestObject(triggerType, auth, parseObject, originalParseObject, config) { + var request = { + triggerName: triggerType, + object: parseObject, + master: false, + log: config.loggerController, + headers: config.headers, + ip: config.ip + }; + + if (originalParseObject) { + request.original = originalParseObject; + } + + if (!auth) { + return request; + } + if (auth.isMaster) { + request['master'] = true; + } + if (auth.user) { + request['user'] = auth.user; + } + if (auth.installationId) { + request['installationId'] = auth.installationId; + } + return request; +} + +function getRequestQueryObject(triggerType, auth, query, count, config, isGet) { + isGet = !!isGet; + + var request = { + triggerName: triggerType, + query, + master: false, + count, + log: config.loggerController, + isGet, + headers: config.headers, + ip: config.ip + }; + + if (!auth) { + return request; + } + if (auth.isMaster) { + request['master'] = true; + } + if (auth.user) { + request['user'] = auth.user; + } + if (auth.installationId) { + request['installationId'] = auth.installationId; + } + return request; +} + +// Creates the response object, and uses the request object to pass data +// The API will call this with REST API formatted objects, this will +// transform them to Parse.Object instances expected by Cloud Code. +// Any changes made to the object in a beforeSave will be included. +function getResponseObject(request, resolve, reject) { + return { + success: function (response) { + if (request.triggerName === Types.afterFind) { + if (!response) { + response = request.objects; + } + response = response.map(object => { + return object.toJSON(); + }); + return resolve(response); + } + // Use the JSON response + if (response && !request.object.equals(response) && request.triggerName === Types.beforeSave) { + return resolve(response); + } + response = {}; + if (request.triggerName === Types.beforeSave) { + response['object'] = request.object._getSaveJSON(); + } + return resolve(response); + }, + error: function (code, message) { + if (!message) { + message = code; + code = _node2.default.Error.SCRIPT_FAILED; + } + var scriptError = new _node2.default.Error(code, message); + return reject(scriptError); + } + }; +} + +function userIdForLog(auth) { + return auth && auth.user ? auth.user.id : undefined; +} + +function logTriggerAfterHook(triggerType, className, input, auth) { + const cleanInput = _logger.logger.truncateLogMessage(JSON.stringify(input)); + _logger.logger.info(`${triggerType} triggered for ${className} for user ${userIdForLog(auth)}:\n Input: ${cleanInput}`, { + className, + triggerType, + user: userIdForLog(auth) + }); +} + +function logTriggerSuccessBeforeHook(triggerType, className, input, result, auth) { + const cleanInput = _logger.logger.truncateLogMessage(JSON.stringify(input)); + const cleanResult = _logger.logger.truncateLogMessage(JSON.stringify(result)); + _logger.logger.info(`${triggerType} triggered for ${className} for user ${userIdForLog(auth)}:\n Input: ${cleanInput}\n Result: ${cleanResult}`, { + className, + triggerType, + user: userIdForLog(auth) + }); +} + +function logTriggerErrorBeforeHook(triggerType, className, input, auth, error) { + const cleanInput = _logger.logger.truncateLogMessage(JSON.stringify(input)); + _logger.logger.error(`${triggerType} failed for ${className} for user ${userIdForLog(auth)}:\n Input: ${cleanInput}\n Error: ${JSON.stringify(error)}`, { + className, + triggerType, + error, + user: userIdForLog(auth) + }); +} + +function maybeRunAfterFindTrigger(triggerType, auth, className, objects, config) { + return new Promise((resolve, reject) => { + const trigger = getTrigger(className, triggerType, config.applicationId); + if (!trigger) { + return resolve(); + } + const request = getRequestObject(triggerType, auth, null, null, config); + const response = getResponseObject(request, object => { + resolve(object); + }, error => { + reject(error); + }); + logTriggerSuccessBeforeHook(triggerType, className, 'AfterFind', JSON.stringify(objects), auth); + request.objects = objects.map(object => { + //setting the class name to transform into parse object + object.className = className; + return _node2.default.Object.fromJSON(object); + }); + const triggerPromise = trigger(request, response); + if (triggerPromise && typeof triggerPromise.then === "function") { + return triggerPromise.then(promiseResults => { + if (promiseResults) { + resolve(promiseResults); + } else { + return reject(new _node2.default.Error(_node2.default.Error.SCRIPT_FAILED, "AfterFind expect results to be returned in the promise")); + } + }); + } + }).then(results => { + logTriggerAfterHook(triggerType, className, JSON.stringify(results), auth); + return results; + }); +} + +function maybeRunQueryTrigger(triggerType, className, restWhere, restOptions, config, auth, isGet) { + const trigger = getTrigger(className, triggerType, config.applicationId); + if (!trigger) { + return Promise.resolve({ + restWhere, + restOptions + }); + } + + const parseQuery = new _node2.default.Query(className); + if (restWhere) { + parseQuery._where = restWhere; + } + let count = false; + if (restOptions) { + if (restOptions.include && restOptions.include.length > 0) { + parseQuery._include = restOptions.include.split(','); + } + if (restOptions.skip) { + parseQuery._skip = restOptions.skip; + } + if (restOptions.limit) { + parseQuery._limit = restOptions.limit; + } + count = !!restOptions.count; + } + const requestObject = getRequestQueryObject(triggerType, auth, parseQuery, count, config, isGet); + return Promise.resolve().then(() => { + return trigger(requestObject); + }).then(result => { + let queryResult = parseQuery; + if (result && result instanceof _node2.default.Query) { + queryResult = result; + } + const jsonQuery = queryResult.toJSON(); + if (jsonQuery.where) { + restWhere = jsonQuery.where; + } + if (jsonQuery.limit) { + restOptions = restOptions || {}; + restOptions.limit = jsonQuery.limit; + } + if (jsonQuery.skip) { + restOptions = restOptions || {}; + restOptions.skip = jsonQuery.skip; + } + if (jsonQuery.include) { + restOptions = restOptions || {}; + restOptions.include = jsonQuery.include; + } + if (jsonQuery.keys) { + restOptions = restOptions || {}; + restOptions.keys = jsonQuery.keys; + } + if (requestObject.readPreference) { + restOptions = restOptions || {}; + restOptions.readPreference = requestObject.readPreference; + } + if (requestObject.includeReadPreference) { + restOptions = restOptions || {}; + restOptions.includeReadPreference = requestObject.includeReadPreference; + } + if (requestObject.subqueryReadPreference) { + restOptions = restOptions || {}; + restOptions.subqueryReadPreference = requestObject.subqueryReadPreference; + } + return { + restWhere, + restOptions + }; + }, err => { + if (typeof err === 'string') { + throw new _node2.default.Error(1, err); + } else { + throw err; + } + }); +} + +// To be used as part of the promise chain when saving/deleting an object +// Will resolve successfully if no trigger is configured +// Resolves to an object, empty or containing an object key. A beforeSave +// trigger will set the object key to the rest format object to save. +// originalParseObject is optional, we only need that for before/afterSave functions +function maybeRunTrigger(triggerType, auth, parseObject, originalParseObject, config) { + if (!parseObject) { + return Promise.resolve({}); + } + return new Promise(function (resolve, reject) { + var trigger = getTrigger(parseObject.className, triggerType, config.applicationId); + if (!trigger) return resolve(); + var request = getRequestObject(triggerType, auth, parseObject, originalParseObject, config); + var response = getResponseObject(request, object => { + logTriggerSuccessBeforeHook(triggerType, parseObject.className, parseObject.toJSON(), object, auth); + resolve(object); + }, error => { + logTriggerErrorBeforeHook(triggerType, parseObject.className, parseObject.toJSON(), auth, error); + reject(error); + }); + // Force the current Parse app before the trigger + _node2.default.applicationId = config.applicationId; + _node2.default.javascriptKey = config.javascriptKey || ''; + _node2.default.masterKey = config.masterKey; + + // AfterSave and afterDelete triggers can return a promise, which if they + // do, needs to be resolved before this promise is resolved, + // so trigger execution is synced with RestWrite.execute() call. + // If triggers do not return a promise, they can run async code parallel + // to the RestWrite.execute() call. + var triggerPromise = trigger(request, response); + if (triggerType === Types.afterSave || triggerType === Types.afterDelete) { + logTriggerAfterHook(triggerType, parseObject.className, parseObject.toJSON(), auth); + if (triggerPromise && typeof triggerPromise.then === "function") { + return triggerPromise.then(resolve, resolve); + } else { + return resolve(); + } + } + }); +} + +// Converts a REST-format object to a Parse.Object +// data is either className or an object +function inflate(data, restObject) { + var copy = typeof data == 'object' ? data : { className: data }; + for (var key in restObject) { + copy[key] = restObject[key]; + } + return _node2.default.Object.fromJSON(copy); +} + +function runLiveQueryEventHandlers(data, applicationId = _node2.default.applicationId) { + if (!_triggerStore || !_triggerStore[applicationId] || !_triggerStore[applicationId].LiveQuery) { + return; + } + _triggerStore[applicationId].LiveQuery.forEach(handler => handler(data)); +} \ No newline at end of file diff --git a/lib/vendor/README.md b/lib/vendor/README.md new file mode 100644 index 0000000000..6bcf5df262 --- /dev/null +++ b/lib/vendor/README.md @@ -0,0 +1,8 @@ +# mongoUrl + +A fork of node's `url` module, with the modification that commas and colons are +allowed in hostnames. While this results in a slightly incorrect parsed result, +as the hostname field for a mongodb should be an array of replica sets, it's +good enough to let us pull out and escape the auth portion of the URL. + +https://github.com/parse-community/parse-server/pull/986 diff --git a/lib/vendor/mongodbUrl.js b/lib/vendor/mongodbUrl.js new file mode 100644 index 0000000000..091ed8e742 --- /dev/null +++ b/lib/vendor/mongodbUrl.js @@ -0,0 +1,924 @@ +// A slightly patched version of node's url module, with support for mongodb:// +// uris. +// +// See https://github.com/nodejs/node/blob/master/LICENSE for licensing +// information + +'use strict'; + +const punycode = require('punycode'); + +exports.parse = urlParse; +exports.resolve = urlResolve; +exports.resolveObject = urlResolveObject; +exports.format = urlFormat; + +exports.Url = Url; + +function Url() { + this.protocol = null; + this.slashes = null; + this.auth = null; + this.host = null; + this.port = null; + this.hostname = null; + this.hash = null; + this.search = null; + this.query = null; + this.pathname = null; + this.path = null; + this.href = null; +} + +// Reference: RFC 3986, RFC 1808, RFC 2396 + +// define these here so at least they only have to be +// compiled once on the first module load. +const protocolPattern = /^([a-z0-9.+-]+:)/i; +const portPattern = /:[0-9]*$/; + +// Special case for a simple path URL +const simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/; + +const hostnameMaxLen = 255; +// protocols that can allow "unsafe" and "unwise" chars. +const unsafeProtocol = { + 'javascript': true, + 'javascript:': true +}; +// protocols that never have a hostname. +const hostlessProtocol = { + 'javascript': true, + 'javascript:': true +}; +// protocols that always contain a // bit. +const slashedProtocol = { + 'http': true, + 'http:': true, + 'https': true, + 'https:': true, + 'ftp': true, + 'ftp:': true, + 'gopher': true, + 'gopher:': true, + 'file': true, + 'file:': true +}; +const querystring = require('querystring'); + +/* istanbul ignore next: improve coverage */ +function urlParse(url, parseQueryString, slashesDenoteHost) { + if (url instanceof Url) return url; + + var u = new Url(); + u.parse(url, parseQueryString, slashesDenoteHost); + return u; +} + +/* istanbul ignore next: improve coverage */ +Url.prototype.parse = function (url, parseQueryString, slashesDenoteHost) { + if (typeof url !== 'string') { + throw new TypeError('Parameter "url" must be a string, not ' + typeof url); + } + + // Copy chrome, IE, opera backslash-handling behavior. + // Back slashes before the query string get converted to forward slashes + // See: https://code.google.com/p/chromium/issues/detail?id=25916 + var hasHash = false; + var start = -1; + var end = -1; + var rest = ''; + var lastPos = 0; + var i = 0; + for (var inWs = false, split = false; i < url.length; ++i) { + const code = url.charCodeAt(i); + + // Find first and last non-whitespace characters for trimming + const isWs = code === 32 /* */ || code === 9 /*\t*/ || code === 13 /*\r*/ || code === 10 /*\n*/ || code === 12 /*\f*/ || code === 160 /*\u00A0*/ || code === 65279 /*\uFEFF*/; + if (start === -1) { + if (isWs) continue; + lastPos = start = i; + } else { + if (inWs) { + if (!isWs) { + end = -1; + inWs = false; + } + } else if (isWs) { + end = i; + inWs = true; + } + } + + // Only convert backslashes while we haven't seen a split character + if (!split) { + switch (code) { + case 35: + // '#' + hasHash = true; + // Fall through + case 63: + // '?' + split = true; + break; + case 92: + // '\\' + if (i - lastPos > 0) rest += url.slice(lastPos, i); + rest += '/'; + lastPos = i + 1; + break; + } + } else if (!hasHash && code === 35 /*#*/) { + hasHash = true; + } + } + + // Check if string was non-empty (including strings with only whitespace) + if (start !== -1) { + if (lastPos === start) { + // We didn't convert any backslashes + + if (end === -1) { + if (start === 0) rest = url;else rest = url.slice(start); + } else { + rest = url.slice(start, end); + } + } else if (end === -1 && lastPos < url.length) { + // We converted some backslashes and have only part of the entire string + rest += url.slice(lastPos); + } else if (end !== -1 && lastPos < end) { + // We converted some backslashes and have only part of the entire string + rest += url.slice(lastPos, end); + } + } + + if (!slashesDenoteHost && !hasHash) { + // Try fast path regexp + const simplePath = simplePathPattern.exec(rest); + if (simplePath) { + this.path = rest; + this.href = rest; + this.pathname = simplePath[1]; + if (simplePath[2]) { + this.search = simplePath[2]; + if (parseQueryString) { + this.query = querystring.parse(this.search.slice(1)); + } else { + this.query = this.search.slice(1); + } + } else if (parseQueryString) { + this.search = ''; + this.query = {}; + } + return this; + } + } + + var proto = protocolPattern.exec(rest); + if (proto) { + proto = proto[0]; + var lowerProto = proto.toLowerCase(); + this.protocol = lowerProto; + rest = rest.slice(proto.length); + } + + // figure out if it's got a host + // user@server is *always* interpreted as a hostname, and url + // resolution will treat //foo/bar as host=foo,path=bar because that's + // how the browser resolves relative URLs. + if (slashesDenoteHost || proto || /^\/\/[^@\/]+@[^@\/]+/.test(rest)) { + var slashes = rest.charCodeAt(0) === 47 /*/*/ && rest.charCodeAt(1) === 47 /*/*/; + if (slashes && !(proto && hostlessProtocol[proto])) { + rest = rest.slice(2); + this.slashes = true; + } + } + + if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) { + + // there's a hostname. + // the first instance of /, ?, ;, or # ends the host. + // + // If there is an @ in the hostname, then non-host chars *are* allowed + // to the left of the last @ sign, unless some host-ending character + // comes *before* the @-sign. + // URLs are obnoxious. + // + // ex: + // http://a@b@c/ => user:a@b host:c + // http://a@b?@c => user:a host:b path:/?@c + + // v0.12 TODO(isaacs): This is not quite how Chrome does things. + // Review our test case against browsers more comprehensively. + + var hostEnd = -1; + var atSign = -1; + var nonHost = -1; + for (i = 0; i < rest.length; ++i) { + switch (rest.charCodeAt(i)) { + case 9: // '\t' + case 10: // '\n' + case 13: // '\r' + case 32: // ' ' + case 34: // '"' + case 37: // '%' + case 39: // '\'' + case 59: // ';' + case 60: // '<' + case 62: // '>' + case 92: // '\\' + case 94: // '^' + case 96: // '`' + case 123: // '{' + case 124: // '|' + case 125: + // '}' + // Characters that are never ever allowed in a hostname from RFC 2396 + if (nonHost === -1) nonHost = i; + break; + case 35: // '#' + case 47: // '/' + case 63: + // '?' + // Find the first instance of any host-ending characters + if (nonHost === -1) nonHost = i; + hostEnd = i; + break; + case 64: + // '@' + // At this point, either we have an explicit point where the + // auth portion cannot go past, or the last @ char is the decider. + atSign = i; + nonHost = -1; + break; + } + if (hostEnd !== -1) break; + } + start = 0; + if (atSign !== -1) { + this.auth = decodeURIComponent(rest.slice(0, atSign)); + start = atSign + 1; + } + if (nonHost === -1) { + this.host = rest.slice(start); + rest = ''; + } else { + this.host = rest.slice(start, nonHost); + rest = rest.slice(nonHost); + } + + // pull out port. + this.parseHost(); + + // we've indicated that there is a hostname, + // so even if it's empty, it has to be present. + if (typeof this.hostname !== 'string') this.hostname = ''; + + var hostname = this.hostname; + + // if hostname begins with [ and ends with ] + // assume that it's an IPv6 address. + var ipv6Hostname = hostname.charCodeAt(0) === 91 /*[*/ && hostname.charCodeAt(hostname.length - 1) === 93 /*]*/; + + // validate a little. + if (!ipv6Hostname) { + const result = validateHostname(this, rest, hostname); + if (result !== undefined) rest = result; + } + + if (this.hostname.length > hostnameMaxLen) { + this.hostname = ''; + } else { + // hostnames are always lower case. + this.hostname = this.hostname.toLowerCase(); + } + + if (!ipv6Hostname) { + // IDNA Support: Returns a punycoded representation of "domain". + // It only converts parts of the domain name that + // have non-ASCII characters, i.e. it doesn't matter if + // you call it with a domain that already is ASCII-only. + this.hostname = punycode.toASCII(this.hostname); + } + + var p = this.port ? ':' + this.port : ''; + var h = this.hostname || ''; + this.host = h + p; + + // strip [ and ] from the hostname + // the host field still retains them, though + if (ipv6Hostname) { + this.hostname = this.hostname.slice(1, -1); + if (rest[0] !== '/') { + rest = '/' + rest; + } + } + } + + // now rest is set to the post-host stuff. + // chop off any delim chars. + if (!unsafeProtocol[lowerProto]) { + // First, make 100% sure that any "autoEscape" chars get + // escaped, even if encodeURIComponent doesn't think they + // need to be. + const result = autoEscapeStr(rest); + if (result !== undefined) rest = result; + } + + var questionIdx = -1; + var hashIdx = -1; + for (i = 0; i < rest.length; ++i) { + const code = rest.charCodeAt(i); + if (code === 35 /*#*/) { + this.hash = rest.slice(i); + hashIdx = i; + break; + } else if (code === 63 /*?*/ && questionIdx === -1) { + questionIdx = i; + } + } + + if (questionIdx !== -1) { + if (hashIdx === -1) { + this.search = rest.slice(questionIdx); + this.query = rest.slice(questionIdx + 1); + } else { + this.search = rest.slice(questionIdx, hashIdx); + this.query = rest.slice(questionIdx + 1, hashIdx); + } + if (parseQueryString) { + this.query = querystring.parse(this.query); + } + } else if (parseQueryString) { + // no query string, but parseQueryString still requested + this.search = ''; + this.query = {}; + } + + var firstIdx = questionIdx !== -1 && (hashIdx === -1 || questionIdx < hashIdx) ? questionIdx : hashIdx; + if (firstIdx === -1) { + if (rest.length > 0) this.pathname = rest; + } else if (firstIdx > 0) { + this.pathname = rest.slice(0, firstIdx); + } + if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) { + this.pathname = '/'; + } + + // to support http.request + if (this.pathname || this.search) { + const p = this.pathname || ''; + const s = this.search || ''; + this.path = p + s; + } + + // finally, reconstruct the href based on what has been validated. + this.href = this.format(); + return this; +}; + +/* istanbul ignore next: improve coverage */ +function validateHostname(self, rest, hostname) { + for (var i = 0, lastPos; i <= hostname.length; ++i) { + var code; + if (i < hostname.length) code = hostname.charCodeAt(i); + if (code === 46 /*.*/ || i === hostname.length) { + if (i - lastPos > 0) { + if (i - lastPos > 63) { + self.hostname = hostname.slice(0, lastPos + 63); + return '/' + hostname.slice(lastPos + 63) + rest; + } + } + lastPos = i + 1; + continue; + } else if (code >= 48 /*0*/ && code <= 57 /*9*/ || code >= 97 /*a*/ && code <= 122 /*z*/ || code === 45 /*-*/ || code >= 65 /*A*/ && code <= 90 /*Z*/ || code === 43 /*+*/ || code === 95 /*_*/ || + /* BEGIN MONGO URI PATCH */ + code === 44 /*,*/ || code === 58 /*:*/ || + /* END MONGO URI PATCH */ + code > 127) { + continue; + } + // Invalid host character + self.hostname = hostname.slice(0, i); + if (i < hostname.length) return '/' + hostname.slice(i) + rest; + break; + } +} + +/* istanbul ignore next: improve coverage */ +function autoEscapeStr(rest) { + var newRest = ''; + var lastPos = 0; + for (var i = 0; i < rest.length; ++i) { + // Automatically escape all delimiters and unwise characters from RFC 2396 + // Also escape single quotes in case of an XSS attack + switch (rest.charCodeAt(i)) { + case 9: + // '\t' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%09'; + lastPos = i + 1; + break; + case 10: + // '\n' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%0A'; + lastPos = i + 1; + break; + case 13: + // '\r' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%0D'; + lastPos = i + 1; + break; + case 32: + // ' ' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%20'; + lastPos = i + 1; + break; + case 34: + // '"' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%22'; + lastPos = i + 1; + break; + case 39: + // '\'' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%27'; + lastPos = i + 1; + break; + case 60: + // '<' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%3C'; + lastPos = i + 1; + break; + case 62: + // '>' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%3E'; + lastPos = i + 1; + break; + case 92: + // '\\' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%5C'; + lastPos = i + 1; + break; + case 94: + // '^' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%5E'; + lastPos = i + 1; + break; + case 96: + // '`' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%60'; + lastPos = i + 1; + break; + case 123: + // '{' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%7B'; + lastPos = i + 1; + break; + case 124: + // '|' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%7C'; + lastPos = i + 1; + break; + case 125: + // '}' + if (i - lastPos > 0) newRest += rest.slice(lastPos, i); + newRest += '%7D'; + lastPos = i + 1; + break; + } + } + if (lastPos === 0) return; + if (lastPos < rest.length) return newRest + rest.slice(lastPos);else return newRest; +} + +// format a parsed object into a url string +/* istanbul ignore next: improve coverage */ +function urlFormat(obj) { + // ensure it's an object, and not a string url. + // If it's an obj, this is a no-op. + // this way, you can call url_format() on strings + // to clean up potentially wonky urls. + if (typeof obj === 'string') obj = urlParse(obj);else if (typeof obj !== 'object' || obj === null) throw new TypeError('Parameter "urlObj" must be an object, not ' + obj === null ? 'null' : typeof obj);else if (!(obj instanceof Url)) return Url.prototype.format.call(obj); + + return obj.format(); +} + +/* istanbul ignore next: improve coverage */ +Url.prototype.format = function () { + var auth = this.auth || ''; + if (auth) { + auth = encodeAuth(auth); + auth += '@'; + } + + var protocol = this.protocol || ''; + var pathname = this.pathname || ''; + var hash = this.hash || ''; + var host = false; + var query = ''; + + if (this.host) { + host = auth + this.host; + } else if (this.hostname) { + host = auth + (this.hostname.indexOf(':') === -1 ? this.hostname : '[' + this.hostname + ']'); + if (this.port) { + host += ':' + this.port; + } + } + + if (this.query !== null && typeof this.query === 'object') query = querystring.stringify(this.query); + + var search = this.search || query && '?' + query || ''; + + if (protocol && protocol.charCodeAt(protocol.length - 1) !== 58 /*:*/) protocol += ':'; + + var newPathname = ''; + var lastPos = 0; + for (var i = 0; i < pathname.length; ++i) { + switch (pathname.charCodeAt(i)) { + case 35: + // '#' + if (i - lastPos > 0) newPathname += pathname.slice(lastPos, i); + newPathname += '%23'; + lastPos = i + 1; + break; + case 63: + // '?' + if (i - lastPos > 0) newPathname += pathname.slice(lastPos, i); + newPathname += '%3F'; + lastPos = i + 1; + break; + } + } + if (lastPos > 0) { + if (lastPos !== pathname.length) pathname = newPathname + pathname.slice(lastPos);else pathname = newPathname; + } + + // only the slashedProtocols get the //. Not mailto:, xmpp:, etc. + // unless they had them to begin with. + if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) { + host = '//' + (host || ''); + if (pathname && pathname.charCodeAt(0) !== 47 /*/*/) pathname = '/' + pathname; + } else if (!host) { + host = ''; + } + + search = search.replace('#', '%23'); + + if (hash && hash.charCodeAt(0) !== 35 /*#*/) hash = '#' + hash; + if (search && search.charCodeAt(0) !== 63 /*?*/) search = '?' + search; + + return protocol + host + pathname + search + hash; +}; + +/* istanbul ignore next: improve coverage */ +function urlResolve(source, relative) { + return urlParse(source, false, true).resolve(relative); +} + +/* istanbul ignore next: improve coverage */ +Url.prototype.resolve = function (relative) { + return this.resolveObject(urlParse(relative, false, true)).format(); +}; + +/* istanbul ignore next: improve coverage */ +function urlResolveObject(source, relative) { + if (!source) return relative; + return urlParse(source, false, true).resolveObject(relative); +} + +/* istanbul ignore next: improve coverage */ +Url.prototype.resolveObject = function (relative) { + if (typeof relative === 'string') { + var rel = new Url(); + rel.parse(relative, false, true); + relative = rel; + } + + var result = new Url(); + var tkeys = Object.keys(this); + for (var tk = 0; tk < tkeys.length; tk++) { + var tkey = tkeys[tk]; + result[tkey] = this[tkey]; + } + + // hash is always overridden, no matter what. + // even href="" will remove it. + result.hash = relative.hash; + + // if the relative url is empty, then there's nothing left to do here. + if (relative.href === '') { + result.href = result.format(); + return result; + } + + // hrefs like //foo/bar always cut to the protocol. + if (relative.slashes && !relative.protocol) { + // take everything except the protocol from relative + var rkeys = Object.keys(relative); + for (var rk = 0; rk < rkeys.length; rk++) { + var rkey = rkeys[rk]; + if (rkey !== 'protocol') result[rkey] = relative[rkey]; + } + + //urlParse appends trailing / to urls like http://www.example.com + if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) { + result.path = result.pathname = '/'; + } + + result.href = result.format(); + return result; + } + + if (relative.protocol && relative.protocol !== result.protocol) { + // if it's a known url protocol, then changing + // the protocol does weird things + // first, if it's not file:, then we MUST have a host, + // and if there was a path + // to begin with, then we MUST have a path. + // if it is file:, then the host is dropped, + // because that's known to be hostless. + // anything else is assumed to be absolute. + if (!slashedProtocol[relative.protocol]) { + var keys = Object.keys(relative); + for (var v = 0; v < keys.length; v++) { + var k = keys[v]; + result[k] = relative[k]; + } + result.href = result.format(); + return result; + } + + result.protocol = relative.protocol; + if (!relative.host && !/^file:?$/.test(relative.protocol) && !hostlessProtocol[relative.protocol]) { + const relPath = (relative.pathname || '').split('/'); + while (relPath.length && !(relative.host = relPath.shift())); + if (!relative.host) relative.host = ''; + if (!relative.hostname) relative.hostname = ''; + if (relPath[0] !== '') relPath.unshift(''); + if (relPath.length < 2) relPath.unshift(''); + result.pathname = relPath.join('/'); + } else { + result.pathname = relative.pathname; + } + result.search = relative.search; + result.query = relative.query; + result.host = relative.host || ''; + result.auth = relative.auth; + result.hostname = relative.hostname || relative.host; + result.port = relative.port; + // to support http.request + if (result.pathname || result.search) { + var p = result.pathname || ''; + var s = result.search || ''; + result.path = p + s; + } + result.slashes = result.slashes || relative.slashes; + result.href = result.format(); + return result; + } + + var isSourceAbs = result.pathname && result.pathname.charAt(0) === '/'; + var isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === '/'; + var mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname; + var removeAllDots = mustEndAbs; + var srcPath = result.pathname && result.pathname.split('/') || []; + var relPath = relative.pathname && relative.pathname.split('/') || []; + var psychotic = result.protocol && !slashedProtocol[result.protocol]; + + // if the url is a non-slashed url, then relative + // links like ../.. should be able + // to crawl up to the hostname, as well. This is strange. + // result.protocol has already been set by now. + // Later on, put the first path part into the host field. + if (psychotic) { + result.hostname = ''; + result.port = null; + if (result.host) { + if (srcPath[0] === '') srcPath[0] = result.host;else srcPath.unshift(result.host); + } + result.host = ''; + if (relative.protocol) { + relative.hostname = null; + relative.port = null; + if (relative.host) { + if (relPath[0] === '') relPath[0] = relative.host;else relPath.unshift(relative.host); + } + relative.host = null; + } + mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === ''); + } + + if (isRelAbs) { + // it's absolute. + result.host = relative.host || relative.host === '' ? relative.host : result.host; + result.hostname = relative.hostname || relative.hostname === '' ? relative.hostname : result.hostname; + result.search = relative.search; + result.query = relative.query; + srcPath = relPath; + // fall through to the dot-handling below. + } else if (relPath.length) { + // it's relative + // throw away the existing file, and take the new path instead. + if (!srcPath) srcPath = []; + srcPath.pop(); + srcPath = srcPath.concat(relPath); + result.search = relative.search; + result.query = relative.query; + } else if (relative.search !== null && relative.search !== undefined) { + // just pull out the search. + // like href='?foo'. + // Put this after the other two cases because it simplifies the booleans + if (psychotic) { + result.hostname = result.host = srcPath.shift(); + //occasionally the auth can get stuck only in host + //this especially happens in cases like + //url.resolveObject('mailto:local1@domain1', 'local2@domain2') + const authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false; + if (authInHost) { + result.auth = authInHost.shift(); + result.host = result.hostname = authInHost.shift(); + } + } + result.search = relative.search; + result.query = relative.query; + //to support http.request + if (result.pathname !== null || result.search !== null) { + result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : ''); + } + result.href = result.format(); + return result; + } + + if (!srcPath.length) { + // no path at all. easy. + // we've already handled the other stuff above. + result.pathname = null; + //to support http.request + if (result.search) { + result.path = '/' + result.search; + } else { + result.path = null; + } + result.href = result.format(); + return result; + } + + // if a url ENDs in . or .., then it must get a trailing slash. + // however, if it ends in anything else non-slashy, + // then it must NOT get a trailing slash. + var last = srcPath.slice(-1)[0]; + var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === '.' || last === '..') || last === ''; + + // strip single dots, resolve double dots to parent dir + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = srcPath.length; i >= 0; i--) { + last = srcPath[i]; + if (last === '.') { + spliceOne(srcPath, i); + } else if (last === '..') { + spliceOne(srcPath, i); + up++; + } else if (up) { + spliceOne(srcPath, i); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (!mustEndAbs && !removeAllDots) { + for (; up--; up) { + srcPath.unshift('..'); + } + } + + if (mustEndAbs && srcPath[0] !== '' && (!srcPath[0] || srcPath[0].charAt(0) !== '/')) { + srcPath.unshift(''); + } + + if (hasTrailingSlash && srcPath.join('/').substr(-1) !== '/') { + srcPath.push(''); + } + + var isAbsolute = srcPath[0] === '' || srcPath[0] && srcPath[0].charAt(0) === '/'; + + // put the host back + if (psychotic) { + result.hostname = result.host = isAbsolute ? '' : srcPath.length ? srcPath.shift() : ''; + //occasionally the auth can get stuck only in host + //this especially happens in cases like + //url.resolveObject('mailto:local1@domain1', 'local2@domain2') + const authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false; + if (authInHost) { + result.auth = authInHost.shift(); + result.host = result.hostname = authInHost.shift(); + } + } + + mustEndAbs = mustEndAbs || result.host && srcPath.length; + + if (mustEndAbs && !isAbsolute) { + srcPath.unshift(''); + } + + if (!srcPath.length) { + result.pathname = null; + result.path = null; + } else { + result.pathname = srcPath.join('/'); + } + + //to support request.http + if (result.pathname !== null || result.search !== null) { + result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : ''); + } + result.auth = relative.auth || result.auth; + result.slashes = result.slashes || relative.slashes; + result.href = result.format(); + return result; +}; + +/* istanbul ignore next: improve coverage */ +Url.prototype.parseHost = function () { + var host = this.host; + var port = portPattern.exec(host); + if (port) { + port = port[0]; + if (port !== ':') { + this.port = port.slice(1); + } + host = host.slice(0, host.length - port.length); + } + if (host) this.hostname = host; +}; + +// About 1.5x faster than the two-arg version of Array#splice(). +/* istanbul ignore next: improve coverage */ +function spliceOne(list, index) { + for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) list[i] = list[k]; + list.pop(); +} + +var hexTable = new Array(256); +for (var i = 0; i < 256; ++i) hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase(); +/* istanbul ignore next: improve coverage */ +function encodeAuth(str) { + // faster encodeURIComponent alternative for encoding auth uri components + var out = ''; + var lastPos = 0; + for (var i = 0; i < str.length; ++i) { + var c = str.charCodeAt(i); + + // These characters do not need escaping: + // ! - . _ ~ + // ' ( ) * : + // digits + // alpha (uppercase) + // alpha (lowercase) + if (c === 0x21 || c === 0x2D || c === 0x2E || c === 0x5F || c === 0x7E || c >= 0x27 && c <= 0x2A || c >= 0x30 && c <= 0x3A || c >= 0x41 && c <= 0x5A || c >= 0x61 && c <= 0x7A) { + continue; + } + + if (i - lastPos > 0) out += str.slice(lastPos, i); + + lastPos = i + 1; + + // Other ASCII characters + if (c < 0x80) { + out += hexTable[c]; + continue; + } + + // Multi-byte characters ... + if (c < 0x800) { + out += hexTable[0xC0 | c >> 6] + hexTable[0x80 | c & 0x3F]; + continue; + } + if (c < 0xD800 || c >= 0xE000) { + out += hexTable[0xE0 | c >> 12] + hexTable[0x80 | c >> 6 & 0x3F] + hexTable[0x80 | c & 0x3F]; + continue; + } + // Surrogate pair + ++i; + var c2; + if (i < str.length) c2 = str.charCodeAt(i) & 0x3FF;else c2 = 0; + c = 0x10000 + ((c & 0x3FF) << 10 | c2); + out += hexTable[0xF0 | c >> 18] + hexTable[0x80 | c >> 12 & 0x3F] + hexTable[0x80 | c >> 6 & 0x3F] + hexTable[0x80 | c & 0x3F]; + } + if (lastPos === 0) return str; + if (lastPos < str.length) return out + str.slice(lastPos); + return out; +} \ No newline at end of file diff --git a/package.json b/package.json index 0a6ce60975..529f9c17f8 100644 --- a/package.json +++ b/package.json @@ -22,6 +22,8 @@ "@parse/push-adapter": "2.0.2", "@parse/s3-files-adapter": "1.2.1", "@parse/simple-mailgun-adapter": "1.0.1", + "adm-zip": "0.4.7", + "archiver": "1.3.0", "bcryptjs": "2.4.3", "body-parser": "1.18.2", "commander": "2.12.1", @@ -38,6 +40,7 @@ "redis": "2.8.0", "request": "2.83.0", "semver": "5.4.1", + "tmp": "0.0.33", "tv4": "1.3.0", "uuid": "^3.1.0", "winston": "2.4.0", diff --git a/spec/Export.spec.js b/spec/Export.spec.js new file mode 100644 index 0000000000..961c99cb0b --- /dev/null +++ b/spec/Export.spec.js @@ -0,0 +1,139 @@ +const Parse = require("parse/node"); +const request = require('request'); +const AdmZip = require('adm-zip'); + +describe('Export router', () => { + + const headers = { + 'Content-Type': 'application/json', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + + const createRecords = (itemCount) => { + const ExportTest = Parse.Object.extend("ExportTest"); + + const items = new Array(itemCount).fill().map((item, index) => { + + const exportTest = new ExportTest(); + + exportTest.set('field1', `value1-${index}`); + exportTest.set('field2', `value2-${index}`); + + return exportTest; + }); + + + return Parse.Object.saveAll(items); + }; + + it_exclude_dbs(['postgres'])('should create export progress', (done) => { + + reconfigureServer({ + emailAdapter : { + sendMail : () => { + done(); + } + } + }) + .then(() => { + return createRecords(3000); + }) + .then(() => { + request.put( + { + headers: headers, + url: 'http://localhost:8378/1/export_data', + body: JSON.stringify({ + name: 'ExportTest', + feedbackEmail: 'my@email.com' + }) + }, + () => { + + request.get( + { + headers: headers, + url: 'http://localhost:8378/1/export_progress' + }, + (err, response, body) => { + + const progress = JSON.parse(body); + + expect(progress instanceof Array).toBe(true); + expect(progress.length).toBe(1); + + if (progress.length) { + expect(progress[0].id).toBe('ExportTest'); + } + }); + } + ); + } + ).catch(fail); + }); + + it_exclude_dbs(['postgres'])('send success export mail', (done) => { + + let results = []; + + const emailAdapter = { + sendMail: ({ link, to, subject}) => { + + expect(to).toEqual('my@email.com'); + expect(subject).toEqual('Export completed'); + + request.get({ url: link, encoding: null }, function(err, res, zipFile) { + + if(err) throw err; + + const zip = new AdmZip(zipFile); + const zipEntries = zip.getEntries(); + + expect(zipEntries.length).toEqual(1); + + const entry = zipEntries.pop(); + const text = entry.getData().toString('utf8'); + const resultsToCompare = JSON.parse(text); + + expect(results.length).toEqual(resultsToCompare.length); + + done(); + }); + } + } + reconfigureServer({ + emailAdapter: emailAdapter, + publicServerURL: "http://localhost:8378/1" + }) + .then(() => { + return createRecords(2176); + }) + .then(() => { + request.get( + { + headers: headers, + url: 'http://localhost:8378/1/classes/ExportTest', + }, + (err, response, body) => { + results = JSON.parse(body); + + request.put( + { + headers: headers, + url: 'http://localhost:8378/1/export_data', + body: JSON.stringify({ + name: 'ExportTest', + feedbackEmail: 'my@email.com' + }) + }, + (err, response, body) => { + expect(err).toBe(null); + expect(body).toEqual('"We are exporting your data. You will be notified by e-mail once it is completed."'); + } + ); + } + ); + }); + }); +}); diff --git a/spec/Import.spec.js b/spec/Import.spec.js new file mode 100644 index 0000000000..06b932ad87 --- /dev/null +++ b/spec/Import.spec.js @@ -0,0 +1,460 @@ +const Parse = require("parse/node"); +const request = require('request'); + +describe('Import routers', () => { + it('import objects from file with array', (done) => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + rows:[ + { column1: 'row1Column1', column2: 'row1Column2' }, + { column1: 'row2Column1', column2: 'row2Column2' } + ] + })), + options: { + filename: 'TestObject.json' + } + } + } + }, + (err) => { + + expect(err).toBe(null); + + const query = new Parse.Query('TestObject'); + query.ascending('column1'); + query.find({}).then((results) => { + expect(results.length).toEqual(2); + expect(results[0].get('column1')).toEqual('row1Column1'); + expect(results[0].get('column2')).toEqual('row1Column2'); + expect(results[1].get('column1')).toEqual('row2Column1'); + expect(results[1].get('column2')).toEqual('row2Column2'); + done(); + }); + } + ); + }); + + it('import objects from file with results field', (done) => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + {column1: 'row1Column1', column2: 'row1Column2'}, + {column1: 'row2Column1', column2: 'row2Column2'} + ] + })), + options: { + filename: 'TestObject.json' + } + } + } + }, + (err) => { + expect(err).toBe(null); + const query = new Parse.Query('TestObject'); + query.ascending('column1'); + query.find().then((results) => { + expect(results.length).toEqual(2); + expect(results[0].get('column1')).toEqual('row1Column1'); + expect(results[0].get('column2')).toEqual('row1Column2'); + expect(results[1].get('column1')).toEqual('row2Column1'); + expect(results[1].get('column2')).toEqual('row2Column2'); + done(); + }); + } + ); + }); + + it('import objects with all data types', (done) => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + { + boolColumnTrue: true, + boolColumnFalse: false, + stringColumn: 'stringColumnValue', + numberColumn: 100.1, + dateColumn: { + '__type': 'Date', + 'iso': '2016-10-30T12:03:56.848Z' + }, + arrayColumn: [ + 1, + 2, + 3 + ], + objectColumn: { + 'key': 'value' + }, + geoColumn: { + '__type': 'GeoPoint', + 'latitude': 10, + 'longitude': -10 + }, + fileColumn: { + '__type': 'File', + 'name': 'myfile.png' + }, + pointerColumn: { + '__type': 'Pointer', + 'className': '_User', + 'objectId': 'AAAAAAAAAA' + } + } + ] + })), + options: { + filename: 'TestObject.json' + } + } + } + }, + (err) => { + expect(err).toBe(null); + const query = new Parse.Query('TestObject'); + query.ascending('column1'); + query.find().then((results) => { + expect(results.length).toEqual(1); + expect(results[0].get('boolColumnTrue')).toEqual(true); + expect(results[0].get('boolColumnFalse')).toEqual(false); + expect(results[0].get('stringColumn')).toEqual('stringColumnValue'); + expect(results[0].get('numberColumn')).toEqual(100.1); + expect(results[0].get('dateColumn')).toEqual(new Date('2016-10-30T12:03:56.848Z')); + expect(results[0].get('arrayColumn')).toEqual([ 1, 2, 3 ]); + expect(results[0].get('objectColumn')).toEqual({ 'key': 'value' }); + expect(results[0].get('geoColumn').latitude).toEqual(10); + expect(results[0].get('geoColumn').longitude).toEqual(-10); + expect(results[0].get('fileColumn').name()).toEqual('myfile.png'); + expect(results[0].get('pointerColumn').id).toEqual('AAAAAAAAAA'); + done(); + }); + } + ); + }); + + it('import objects with object id', (done) => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + { + 'objectId': 'aaaaaaaaaa', + 'data': 'somedataa', + 'createdAt': '2016-07-25T19:45:33.195Z', + 'updatedAt': '2016-10-30T12:23:35.635Z' + }, + { + 'objectId': 'bbbbbbbbbb', + 'data': 'somedatab', + 'createdAt': '2016-07-25T19:45:33.195Z', + 'updatedAt': '2016-10-30T12:23:35.635Z' + } + ] + })), + options: { + filename: 'TestObject.json' + } + } + } + }, + (err) => { + expect(err).toBe(null); + const query = new Parse.Query('TestObject'); + query.ascending('data'); + query.find().then((results) => { + expect(results.length).toEqual(2); + expect(results[0].id).toEqual('aaaaaaaaaa'); + expect(results[1].id).toEqual('bbbbbbbbbb'); + done(); + }); + } + ); + }); + + it('update objects with existing object id', (done) => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + { + 'objectId': 'aaaaaaaaaa', + 'data': 'somedataa' + }, + { + 'objectId': 'bbbbbbbbbb', + 'data': 'somedatab' + } + ] + })), + options: { + filename: 'TestObject.json' + } + } + } + }, + (err) => { + expect(err).toBe(null); + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + { + 'objectId': 'aaaaaaaaaa', + 'data': 'somedataa2' + } + ] + })), + options: { + filename: 'TestObject.json' + } + } + } + }, + (err) => { + expect(err).toBe(null); + const query = new Parse.Query('TestObject'); + query.ascending('data'); + query.find().then((results) => { + expect(results.length).toEqual(2); + expect(results[0].id).toEqual('aaaaaaaaaa'); + expect(results[0].get('data')).toEqual('somedataa2'); + expect(results[1].id).toEqual('bbbbbbbbbb'); + expect(results[1].get('data')).toEqual('somedatab'); + done(); + }); + } + ); + } + ); + }); + + it('send success import mail', (done) => { + const emailAdapter = { + sendMail: ({text, to, subject}) => { + expect(text).toEqual('We have successfully imported your data to the class TestObject.'); + expect(to).toEqual('my@email.com'); + expect(subject).toEqual('Import completed'); + const query = new Parse.Query('TestObject'); + query.ascending('column1'); + query.find().then((results) => { + expect(results.length).toEqual(2); + expect(results[0].get('column1')).toEqual('row1Column1'); + expect(results[0].get('column2')).toEqual('row1Column2'); + expect(results[1].get('column1')).toEqual('row2Column1'); + expect(results[1].get('column2')).toEqual('row2Column2'); + done(); + }); + } + } + reconfigureServer({ + emailAdapter: emailAdapter + }).then(() => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_data/TestObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + {column1: 'row1Column1', column2: 'row1Column2'}, + {column1: 'row2Column1', column2: 'row2Column2'} + ], + })), + options: { + filename: 'TestObject.json' + } + }, + feedbackEmail: 'my@email.com' + } + }, + (err, response, body) => { + expect(err).toBe(null); + expect(JSON.parse(body).response).toEqual('We are importing your data. You will be notified by e-mail once it is completed.'); + } + ); + }); + }); + + it('import relations object from file', (done) => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + + const object = new Parse.Object('TestObjectDad'); + const relatedObject = new Parse.Object('TestObjectChild'); + const ids = {}; + Parse.Object.saveAll([object, relatedObject]).then(() => { + object.relation('RelationObject').add(relatedObject); + return object.save(); + }) + .then(() => { + object.set('Name', 'namea'); + return object.save(); + }) + .then((savedObj) => { + ids.a = savedObj.id; + relatedObject.set('Name', 'nameb'); + return relatedObject.save(); + }) + .then((savedObj) => { + ids.b = savedObj.id; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_relation_data/TestObjectDad/RelationObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + { + 'owningId': ids.a, + 'relatedId': ids.b + } + ] + })), + options: { + filename: 'TestObject:RelationObject.json' + } + } + } + }, + (err) => { + expect(err).toBe(null); + object.relation('RelationObject').query().find().then((results) => { + expect(results.length).toEqual(1); + expect(results[0].id).toEqual(ids.b); + done(); + }); + } + ) + }); + }); + + it('send success import mail in the import relation', (done) => { + const object = new Parse.Object('TestObjectDad'); + const relatedObject = new Parse.Object('TestObjectChild'); + const ids = {}; + Parse.Object.saveAll([object, relatedObject]).then(() => { + object.relation('RelationObject').add(relatedObject); + return object.save(); + }) + .then(() => { + object.set('Name', 'namea'); + return object.save(); + }) + .then((savedObj) => { + ids.a = savedObj.id; + relatedObject.set('Name', 'nameb'); + return relatedObject.save(); + }) + .then((savedObj) => { + ids.b = savedObj.id; + const emailAdapter = { + sendMail: ({text, to, subject}) => { + expect(text).toEqual('We have successfully imported your data to the class TestObjectDad, relation RelationObject.'); + expect(to).toEqual('my@email.com'); + expect(subject).toEqual('Import completed'); + object.relation('RelationObject').query().find().then((results) => { + expect(results.length).toEqual(1); + expect(results[0].id).toEqual(ids.b); + done(); + }); + } + } + reconfigureServer({ + emailAdapter: emailAdapter + }).then(() => { + const headers = { + 'Content-Type': 'multipart/form-data', + 'X-Parse-Application-Id': 'test', + 'X-Parse-Master-Key': 'test' + }; + request.post( + { + headers: headers, + url: 'http://localhost:8378/1/import_relation_data/TestObjectDad/RelationObject', + formData: { + importFile: { + value: Buffer.from(JSON.stringify({ + results: [ + { + 'owningId': ids.a, + 'relatedId': ids.b + } + ] + })), + options: { + filename: 'TestObject:RelationObject.json' + } + }, + feedbackEmail: 'my@email.com' + } + }, + (err, response, body) => { + expect(err).toBe(null); + expect(body).toEqual('{"response":"We are importing your data. You will be notified by e-mail once it is completed."}'); + } + ); + }); + }); + }); +}); diff --git a/src/Adapters/PubSub/RedisPubSub.js b/src/Adapters/PubSub/RedisPubSub.js index 7fb62dfca2..29f4dcf512 100644 --- a/src/Adapters/PubSub/RedisPubSub.js +++ b/src/Adapters/PubSub/RedisPubSub.js @@ -1,18 +1,62 @@ import redis from 'redis'; +import Parse from 'parse/node'; function createPublisher({redisURL}): any { - return redis.createClient(redisURL, { no_ready_check: true }); + var redisCli = redis.createClient(redisURL, { no_ready_check: true }); + + if (redisCli) { + redisCli.publish2 = redisCli.publish; + + redisCli.publish = function (channel, body) { + var bodyObject; + try { + bodyObject = JSON.parse(body); + } catch (e) { + bodyObject = {}; + } + if (bodyObject && bodyObject.pushStatus) { + redisCli.multi([ + ['sadd', bodyObject.applicationId + ':push', body] + ]).exec(); + } + return redisCli.publish2(channel, body); + }; + } + + return redisCli; } function createSubscriber({redisURL}): any { - return redis.createClient(redisURL, { no_ready_check: true }); + var redisCli = redis.createClient(redisURL, { no_ready_check: true }); + var secondaryClient = redis.createClient(redisURL, { no_ready_check: true }); + if (redisCli) { + redisCli.run = function (workItem) { + return new Parse.Promise(function (resolve) { + secondaryClient + .multi([ + ['spop', workItem.applicationId + ':push'] + ]) + .exec(function (err, rep) { + if (!err && rep && rep[0]) { + resolve(JSON.parse(rep[0])); + } else { + resolve(); + } + }) + }); + }; + } + + return redisCli; } const RedisPubSub = { createPublisher, createSubscriber -} +}; export { - RedisPubSub + RedisPubSub, + createPublisher, + createSubscriber } diff --git a/src/Controllers/SchemaController.js b/src/Controllers/SchemaController.js index ab579b6aa2..14a9847d78 100644 --- a/src/Controllers/SchemaController.js +++ b/src/Controllers/SchemaController.js @@ -124,6 +124,12 @@ const defaultColumns = Object.freeze({ "query": {type:'String'}, //storing query as JSON string to prevent "Nested keys should not contain the '$' or '.' characters" error "lastUsed": {type:'Date'}, "timesUsed": {type:'Number'} + }, + _ExportProgress: { + "objectId": {type:'String'}, + "id": {type:'String'}, + "masterKey": {type:'String'}, + "applicationId": {type:'String'} } }); @@ -132,9 +138,9 @@ const requiredColumns = Object.freeze({ _Role: ["name", "ACL"] }); -const systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience']); +const systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience', '_ExportProgress' ]); -const volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule', '_Audience']); +const volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule', '_Audience', '_ExportProgress']); // 10 alpha numberic chars + uppercase const userIdRegex = /^[a-zA-Z0-9]{10}$/; diff --git a/src/ParseServer.js b/src/ParseServer.js index 76631ea3d9..ced6577620 100644 --- a/src/ParseServer.js +++ b/src/ParseServer.js @@ -35,6 +35,8 @@ import { UsersRouter } from './Routers/UsersRouter'; import { PurgeRouter } from './Routers/PurgeRouter'; import { AudiencesRouter } from './Routers/AudiencesRouter'; import { AggregateRouter } from './Routers/AggregateRouter'; +import { ImportRouter } from './Routers/ImportRouter'; +import { ExportRouter } from './Routers/ExportRouter'; import { ParseServerRESTController } from './ParseServerRESTController'; import * as controllers from './Controllers'; @@ -146,6 +148,7 @@ class ParseServer { api.use('/', bodyParser.urlencoded({extended: false}), new PublicAPIRouter().expressRouter()); + api.use('/', middlewares.allowCrossDomain, new ImportRouter().expressRouter()); api.use(bodyParser.json({ 'type': '*/*' , limit: maxUploadSize })); api.use(middlewares.allowCrossDomain); api.use(middlewares.allowMethodOverride); @@ -196,6 +199,7 @@ class ParseServer { new FeaturesRouter(), new GlobalConfigRouter(), new PurgeRouter(), + new ExportRouter(), new HooksRouter(), new CloudCodeRouter(), new AudiencesRouter(), diff --git a/src/Push/PushWorker.js b/src/Push/PushWorker.js index afd4416dc9..f96a281040 100644 --- a/src/Push/PushWorker.js +++ b/src/Push/PushWorker.js @@ -21,7 +21,7 @@ function groupByBadge(installations) { } export class PushWorker { - subscriber: ?any; + subscriber: any; adapter: any; channel: string; @@ -36,7 +36,7 @@ export class PushWorker { subscriber.subscribe(this.channel); subscriber.on('message', (channel, messageStr) => { const workItem = JSON.parse(messageStr); - this.run(workItem); + this.getAndRun(workItem); }); } } @@ -47,7 +47,7 @@ export class PushWorker { } } - run({ body, query, pushStatus, applicationId, UTCOffset }: any): Promise<*> { + run({ body, query, pushStatus, applicationId, UTCOffset }: any): Promise { const config = Config.get(applicationId); const auth = master(config); const where = utils.applyDeviceTokenExists(query.where); @@ -55,7 +55,7 @@ export class PushWorker { pushStatus = pushStatusHandler(config, pushStatus.objectId); return rest.find(config, auth, '_Installation', where, query).then(({results}) => { if (results.length == 0) { - return; + return pushStatus.trackSent(results); } return this.sendToAdapter(body, results, pushStatus, config, UTCOffset); }, err => { @@ -63,7 +63,7 @@ export class PushWorker { }); } - sendToAdapter(body: any, installations: any[], pushStatus: any, config: Config, UTCOffset: ?any): Promise<*> { + sendToAdapter(body: any, installations: any, pushStatus: any, config: Config, UTCOffset: any): Promise { // Check if we have locales in the push body const locales = utils.getLocalesFromPush(body); if (locales.length > 0) { @@ -83,7 +83,8 @@ export class PushWorker { if (!utils.isPushIncrementing(body)) { logger.verbose(`Sending push to ${installations.length}`); return this.adapter.send(body, installations, pushStatus.objectId).then((results) => { - return pushStatus.trackSent(results, UTCOffset).then(() => results); + return pushStatus.trackSent(results, UTCOffset, undefined, installations.length - results.length) + .then(() => results); }); } @@ -99,6 +100,23 @@ export class PushWorker { }); return Promise.all(promises); } + + getAndRun(workItem: any): Promise { + var _this = this; + if (!_this.subscriber.run) { + return _this.run(workItem); + } + return _this.subscriber.run(workItem).then(function (gotItem) { + if (gotItem) { + return _this.run(gotItem) + .then(function () { + return _this.getAndRun(gotItem) + }) + } else { + return Promise.resolve(); + } + }); + } } export default PushWorker; diff --git a/src/RestQuery.js b/src/RestQuery.js index 0af910522b..c7f6a9f29e 100644 --- a/src/RestQuery.js +++ b/src/RestQuery.js @@ -263,7 +263,8 @@ RestQuery.prototype.replaceInQuery = function() { } const additionalOptions = { - redirectClassNameForKey: inQueryValue.redirectClassNameForKey + redirectClassNameForKey: inQueryValue.redirectClassNameForKey, + keys: 'objectId' }; if (this.restOptions.subqueryReadPreference) { @@ -316,7 +317,8 @@ RestQuery.prototype.replaceNotInQuery = function() { } const additionalOptions = { - redirectClassNameForKey: notInQueryValue.redirectClassNameForKey + redirectClassNameForKey: notInQueryValue.redirectClassNameForKey, + keys: 'objectId' }; if (this.restOptions.subqueryReadPreference) { @@ -371,7 +373,8 @@ RestQuery.prototype.replaceSelect = function() { } const additionalOptions = { - redirectClassNameForKey: selectValue.query.redirectClassNameForKey + redirectClassNameForKey: selectValue.query.redirectClassNameForKey, + keys: selectValue.key }; if (this.restOptions.subqueryReadPreference) { @@ -424,7 +427,8 @@ RestQuery.prototype.replaceDontSelect = function() { 'improper usage of $dontSelect'); } const additionalOptions = { - redirectClassNameForKey: dontSelectValue.query.redirectClassNameForKey + redirectClassNameForKey: dontSelectValue.query.redirectClassNameForKey, + keys: dontSelectValue.key }; if (this.restOptions.subqueryReadPreference) { diff --git a/src/RestWrite.js b/src/RestWrite.js index 424284d5ba..439c55bed0 100644 --- a/src/RestWrite.js +++ b/src/RestWrite.js @@ -24,7 +24,7 @@ import logger from './logger'; // RestWrite will handle objectId, createdAt, and updatedAt for // everything. It also knows to use triggers and special modifications // for the _User class. -function RestWrite(config, auth, className, query, data, originalData, clientSDK) { +function RestWrite(config, auth, className, query, data, originalData, clientSDK, options) { if (auth.isReadOnly) { throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform a write operation when using readOnlyMasterKey'); } @@ -34,7 +34,8 @@ function RestWrite(config, auth, className, query, data, originalData, clientSDK this.clientSDK = clientSDK; this.storage = {}; this.runOptions = {}; - if (!query && data.objectId) { + const allowObjectId = options && options.allowObjectId === true; + if (!query && data.objectId && !allowObjectId) { throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.'); } diff --git a/src/Routers/ExportRouter.js b/src/Routers/ExportRouter.js new file mode 100644 index 0000000000..386ce6fcc1 --- /dev/null +++ b/src/Routers/ExportRouter.js @@ -0,0 +1,212 @@ +import PromiseRouter from '../PromiseRouter'; +import { loadAdapter } from '../Adapters/AdapterLoader'; +import rest from '../rest'; +import archiver from 'archiver'; +import tmp from 'tmp'; +import fs from 'fs'; + +const DefaultExportExportProgressCollectionName = "_ExportProgress"; +const relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } }; + +export class ExportRouter extends PromiseRouter { + + exportClassPage(req, name, jsonFileStream, where, skip, limit) { + + const databaseController = req.config.database; + + const options = { + skip, + limit + }; + + const findPromise = name.indexOf('_Join') === 0 ? + databaseController.adapter.find(name, relationSchema, where, options) + : rest.find(req.config, req.auth, name, where, options); + + return findPromise + .then((data) => { + if (Array.isArray(data)) { + data = { results : data }; + } + + if (skip && data.results.length) { + jsonFileStream.write(',\n'); + } + + jsonFileStream.write(JSON.stringify(data.results, null, 2).substr(1).slice(0,-1)); + }); + } + + exportClass(req, data) { + + + const databaseController = req.config.database; + const tmpJsonFile = tmp.fileSync(); + const jsonFileStream = fs.createWriteStream(tmpJsonFile.name); + + jsonFileStream.write('{\n"results" : [\n'); + + const findPromise = data.name.indexOf('_Join') === 0 ? + databaseController.adapter.count(data.name, relationSchema, data.where) + : rest.find(req.config, req.auth, data.name, data.where, { count: true, limit: 0 }); + + return findPromise + .then((result) => { + + if (Number.isInteger(result)) { + result = { count: result }; + } + + let i = 0; + const pageLimit = 1000; + let promise = Promise.resolve(); + + + for (i = 0; i < result.count; i += pageLimit) { + + const skip = i; + promise = promise.then(() => { + return this.exportClassPage(req, data.name, jsonFileStream, data.where, skip, pageLimit); + }); + } + + return promise; + }) + .then(() => { + + jsonFileStream.end(']\n}'); + + return new Promise((resolve) => { + + jsonFileStream.on('close', () => { + tmpJsonFile._name = `${data.name.replace(/:/g,'꞉')}.json`; + + resolve(tmpJsonFile); + }); + }) + }); + } + + handleExportProgress(req) { + + const databaseController = req.config.database; + + const query = { + masterKey: req.info.masterKey, + applicationId: req.info.appId + }; + + return databaseController.find(DefaultExportExportProgressCollectionName, query) + .then((response) => { + return { response }; + }); + } + + handleExport(req) { + + const databaseController = req.config.database; + + const emailControllerAdapter = loadAdapter(req.config.emailAdapter); + + if (!emailControllerAdapter) { + return Promise.reject(new Error('You have to setup a Mail Adapter.')); + } + + const exportProgress = { + id: req.body.name, + masterKey: req.info.masterKey, + applicationId: req.info.appId + }; + + databaseController.create(DefaultExportExportProgressCollectionName, exportProgress) + .then(() => { + return databaseController.loadSchema({ clearCache: true}); + }) + .then(schemaController => schemaController.getOneSchema(req.body.name, true)) + .then((schema) => { + const classNames = [ req.body.name ]; + Object.keys(schema.fields).forEach((fieldName) => { + const field = schema.fields[fieldName]; + + if (field.type === 'Relation') { + classNames.push(`_Join:${fieldName}:${req.body.name}`); + } + }); + + const promisses = classNames.map((name) => { + return this.exportClass(req, { name }); + }); + + return Promise.all(promisses) + }) + .then((jsonFiles) => { + + return new Promise((resolve) => { + const tmpZipFile = tmp.fileSync(); + const tmpZipStream = fs.createWriteStream(tmpZipFile.name); + + const zip = archiver('zip'); + zip.pipe(tmpZipStream); + + jsonFiles.forEach(tmpJsonFile => { + zip.append(fs.readFileSync(tmpJsonFile.name), { name: tmpJsonFile._name }); + tmpJsonFile.removeCallback(); + }); + + zip.finalize(); + + tmpZipStream.on('close', () => { + + const buf = fs.readFileSync(tmpZipFile.name); + tmpZipFile.removeCallback(); + resolve(buf); + + }); + }); + + }) + .then((zippedFile) => { + const filesController = req.config.filesController; + return filesController.createFile(req.config, req.body.name, zippedFile, 'application/zip'); + }) + .then((fileData) => { + + return emailControllerAdapter.sendMail({ + text: `We have successfully exported your data from the class ${req.body.name}.\n + Please download from ${fileData.url}`, + link: fileData.url, + to: req.body.feedbackEmail, + subject: 'Export completed' + }); + }) + .catch((error) => { + return emailControllerAdapter.sendMail({ + text: `We could not export your data to the class ${req.body.name}. Error: ${error}`, + to: req.body.feedbackEmail, + subject: 'Export failed' + }); + }) + .then(() => { + return databaseController.destroy(DefaultExportExportProgressCollectionName, exportProgress); + }); + + return Promise.resolve({response: 'We are exporting your data. You will be notified by e-mail once it is completed.'}); + } + + mountRoutes() { + this.route( + 'PUT', + '/export_data', + (req) => { return this.handleExport(req); } + ); + + this.route( + 'GET', + '/export_progress', + (req) => { return this.handleExportProgress(req); } + ); + + } +} + +export default ExportRouter; diff --git a/src/Routers/FeaturesRouter.js b/src/Routers/FeaturesRouter.js index 47d1a0980c..e74b534c9d 100644 --- a/src/Routers/FeaturesRouter.js +++ b/src/Routers/FeaturesRouter.js @@ -41,7 +41,8 @@ export class FeaturesRouter extends PromiseRouter { addClass: true, removeClass: true, clearAllDataFromClass: true, - exportClass: false, + import: true, + exportClass: true, editClassLevelPermissions: true, editPointerPermissions: true, }, diff --git a/src/Routers/ImportRouter.js b/src/Routers/ImportRouter.js new file mode 100644 index 0000000000..c1cdd68e02 --- /dev/null +++ b/src/Routers/ImportRouter.js @@ -0,0 +1,219 @@ +import express from 'express'; +import { loadAdapter } from '../Adapters/AdapterLoader'; +import * as middlewares from '../middlewares'; +import multer from 'multer'; +import rest from '../rest'; +import { Parse } from 'parse/node'; + +export class ImportRouter { + + getOneSchema(req) { + + const className = req.params.className; + + return req.config.database.loadSchema({clearCache: true}) + .then(schemaController => schemaController.getOneSchema(className)) + .catch(error => { + if (error === undefined) { + return Promise.reject(new Parse.Error(Parse.Error.INVALID_CLASS_NAME, + `Class ${className} does not exist.`)); + } else { + return Promise.reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, + 'Database adapter error.')); + } + }); + } + + importRestObject(req, restObject, targetClass) { + if (targetClass) { + return rest.update(req.config, req.auth, req.params.className, {objectId: restObject.owningId}, { + [req.params.relationName]: { + "__op": "AddRelation", + "objects": [{"__type": "Pointer", "className": targetClass, "objectId": restObject.relatedId}] + } + }, req.info.clientSDK) + .catch(function (error) { + if (error.code === Parse.Error.OBJECT_NOT_FOUND) { + return Promise.reject(new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found')); + } else { + return Promise.reject(error); + } + }); + } + + if (restObject.createdAt) { + delete restObject.createdAt; + } + + if (restObject.updatedAt) { + delete restObject.updatedAt; + } + + if (restObject.objectId) { + return rest + .update(req.config, req.auth, req.params.className, {objectId: restObject.objectId}, restObject, req.info.clientSDK) + .catch(function (error) { + if (error.code === Parse.Error.OBJECT_NOT_FOUND) { + return rest.create( + req.config, + req.auth, + req.params.className, + restObject, + req.info.clientSDK, + {allowObjectId: true} + ) + } else { + return Promise.reject(error); + } + }); + } + + return rest.create(req.config, req.auth, req.params.className, restObject); + } + + getRestObjects(req) { + return new Promise((resolve) => { + + let restObjects = []; + let importFile; + + try { + importFile = JSON.parse(req.file.buffer.toString()); + } catch (e) { + throw new Error('Failed to parse JSON based on the file sent'); + } + + if (Array.isArray(importFile)) { + restObjects = importFile; + } else if (Array.isArray(importFile.results)) { + restObjects = importFile.results; + } else if (Array.isArray(importFile.rows)) { + restObjects = importFile.rows; + } + + if (!restObjects) { + throw new Error('No data to import'); + } + + if (req.body.feedbackEmail) { + if (!req.config.emailAdapter) { + throw new Error('You have to setup a Mail Adapter.'); + } + } + + resolve(restObjects); + }); + } + + handleImport(req) { + + const emailControllerAdapter = loadAdapter(req.config.emailAdapter); + + let promise = null; + + if (req.params.relationName) { + promise = this.getOneSchema(req) + .then((response) => { + if (!response.fields.hasOwnProperty(req.params.relationName)) { + throw new Error(`Relation ${req.params.relationName} does not exist in ${req.params.className}.`); + } else if (response.fields[req.params.relationName].type !== 'Relation') { + throw new Error(`Class ${response.fields[req.params.relationName].targetClass} does not have Relation type.`); + } + + const targetClass = response.fields[req.params.relationName].targetClass; + + return Promise.all([this.getRestObjects(req), targetClass]); + }); + } + else { + promise = Promise.all([this.getRestObjects(req)]); + } + + promise = promise + .then(([restObjects, targetClass]) => { + + return restObjects.reduce((item, object, index) => { + + item.pageArray.push(this.importRestObject.bind(this, req, object, targetClass)); + + if (index && index % 100 === 0 || index === (restObjects.length - 1)) { + + const pageArray = item.pageArray.slice(0); + item.pageArray = []; + + item.mainPromise = item.mainPromise + .then((results) => { + return Promise.all(results.concat(pageArray.map(func => func()))); + }); + + } + + return item; + }, { pageArray: [], mainPromise : Promise.resolve([]) }).mainPromise; + }) + .then((results) => { + if (req.body.feedbackEmail) { + emailControllerAdapter.sendMail({ + text: `We have successfully imported your data to the class ${req.params.className}${req.params.relationName ? ', relation ' + req.params.relationName : '' }.`, + to: req.body.feedbackEmail, + subject: 'Import completed' + }); + } else { + return Promise.resolve({ response: results }); + } + }) + .catch((error) => { + if (req.body.feedbackEmail) { + emailControllerAdapter.sendMail({ + text: `We could not import your data to the class ${req.params.className}${req.params.relationName ? ', relation ' + req.params.relationName : '' }. Error: ${error}`, + to: req.body.feedbackEmail, + subject: 'Import failed' + }); + } else { + throw new Error('Internal server error: ' + error); + } + + }); + + if (req.body.feedbackEmail && emailControllerAdapter) { + promise = Promise.resolve({ response: 'We are importing your data. You will be notified by e-mail once it is completed.' }); + } + + return promise; + } + + wrapPromiseRequest(req, res, handler) { + return handler(req) + .then((data) => { + res.json(data); + }) + .catch((err) => { + res.status(400).send({ message: err.message }); + }) + } + + expressRouter() { + const router = express.Router(); + const upload = multer(); + + router.post('/import_data/:className', + upload.single('importFile'), + middlewares.allowCrossDomain, + middlewares.handleParseHeaders, + middlewares.enforceMasterKeyAccess, + (req, res) => this.wrapPromiseRequest(req, res, this.handleImport.bind(this)) + ); + + router.post('/import_relation_data/:className/:relationName', + upload.single('importFile'), + middlewares.allowCrossDomain, + middlewares.handleParseHeaders, + middlewares.enforceMasterKeyAccess, + (req, res) => this.wrapPromiseRequest(req, res, this.handleImport.bind(this)) + ); + + return router; + } +} + +export default ImportRouter; diff --git a/src/middlewares.js b/src/middlewares.js index 0606ab8f38..18bcaa11a3 100644 --- a/src/middlewares.js +++ b/src/middlewares.js @@ -246,7 +246,7 @@ function decodeBase64(str) { export function allowCrossDomain(req, res, next) { res.header('Access-Control-Allow-Origin', '*'); res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS'); - res.header('Access-Control-Allow-Headers', 'X-Parse-Master-Key, X-Parse-REST-API-Key, X-Parse-Javascript-Key, X-Parse-Application-Id, X-Parse-Client-Version, X-Parse-Session-Token, X-Requested-With, X-Parse-Revocable-Session, Content-Type'); + res.header('Access-Control-Allow-Headers', 'X-Parse-Master-Key, X-Parse-REST-API-Key, X-Parse-Javascript-Key, X-Parse-Application-Id, X-Parse-Client-Version, X-Parse-Session-Token, X-Requested-With, X-Parse-Revocable-Session, Content-Type, X-CSRF-Token'); // intercept OPTIONS method if ('OPTIONS' == req.method) { diff --git a/src/rest.js b/src/rest.js index b428f43cb8..cbfacbcca6 100644 --- a/src/rest.js +++ b/src/rest.js @@ -114,9 +114,9 @@ function del(config, auth, className, objectId) { } // Returns a promise for a {response, status, location} object. -function create(config, auth, className, restObject, clientSDK) { +function create(config, auth, className, restObject, clientSDK, options) { enforceRoleSecurity('create', className, auth); - var write = new RestWrite(config, auth, className, null, restObject, null, clientSDK); + var write = new RestWrite(config, auth, className, null, restObject, null, clientSDK, options); return write.execute(); } From a420fd70485080462432d5ea2c18dc799a44657f Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 22 Aug 2018 14:27:49 -0300 Subject: [PATCH 02/73] Add background true --- lib/Adapters/Storage/Mongo/MongoStorageAdapter.js | 4 ++-- src/Adapters/Storage/Mongo/MongoStorageAdapter.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js index a3b25cfdc8..b93ae9facd 100644 --- a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -589,11 +589,11 @@ class MongoStorageAdapter { } createIndex(className, index) { - return this._adaptiveCollection(className).then(collection => collection._mongoCollection.createIndex(index)).catch(err => this.handleError(err)); + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.createIndex(index, { background: true })).catch(err => this.handleError(err)); } createIndexes(className, indexes) { - return this._adaptiveCollection(className).then(collection => collection._mongoCollection.createIndexes(indexes)).catch(err => this.handleError(err)); + return this._adaptiveCollection(className).then(collection => collection._mongoCollection.createIndexes(indexes, { background: true })).catch(err => this.handleError(err)); } createIndexesIfNeeded(className, fieldName, type) { diff --git a/src/Adapters/Storage/Mongo/MongoStorageAdapter.js b/src/Adapters/Storage/Mongo/MongoStorageAdapter.js index 29614942a0..e1db8b93b2 100644 --- a/src/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/src/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -641,13 +641,13 @@ export class MongoStorageAdapter implements StorageAdapter { createIndex(className: string, index: any) { return this._adaptiveCollection(className) - .then(collection => collection._mongoCollection.createIndex(index)) + .then(collection => collection._mongoCollection.createIndex(index, {background: true})) .catch(err => this.handleError(err)); } createIndexes(className: string, indexes: any) { return this._adaptiveCollection(className) - .then(collection => collection._mongoCollection.createIndexes(indexes)) + .then(collection => collection._mongoCollection.createIndexes(indexes, {background: true})) .catch(err => this.handleError(err)); } From 408d5539548497b55625df19424a160148f20744 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Mon, 3 Sep 2018 10:54:05 -0300 Subject: [PATCH 03/73] Merge from 2.8.4 to master --- .babelrc | 5 +- .github/ISSUE_TEMPLATE/---feature-request.md | 17 + .../ISSUE_TEMPLATE/---push-notifications.md | 7 + .github/ISSUE_TEMPLATE/---report-an-issue.md | 53 + .github/ISSUE_TEMPLATE/Bug_report.md | 51 + .gitignore | 3 + .nvmrc | 1 + .nycrc | 2 +- .travis.yml | 26 +- CHANGELOG.md | 114 +- CONTRIBUTING.md | 51 +- Dockerfile | 2 +- README.md | 17 +- lib/AccountLockout.js | 3 +- lib/Adapters/AdapterLoader.js | 3 +- lib/Adapters/Analytics/AnalyticsAdapter.js | 3 +- lib/Adapters/Auth/AuthAdapter.js | 3 +- lib/Adapters/Auth/OAuth1Client.js | 3 +- lib/Adapters/Auth/facebook.js | 5 +- lib/Adapters/Auth/facebookaccountkit.js | 3 +- lib/Adapters/Auth/github.js | 3 +- lib/Adapters/Auth/google.js | 3 +- lib/Adapters/Auth/index.js | 3 +- lib/Adapters/Auth/instagram.js | 3 +- lib/Adapters/Auth/janraincapture.js | 3 +- lib/Adapters/Auth/janrainengage.js | 3 +- lib/Adapters/Auth/linkedin.js | 3 +- lib/Adapters/Auth/meetup.js | 3 +- lib/Adapters/Auth/qq.js | 3 +- lib/Adapters/Auth/spotify.js | 3 +- lib/Adapters/Auth/twitter.js | 3 +- lib/Adapters/Auth/vkontakte.js | 5 +- lib/Adapters/Auth/wechat.js | 3 +- lib/Adapters/Auth/weibo.js | 3 +- lib/Adapters/Cache/CacheAdapter.js | 3 +- lib/Adapters/Cache/InMemoryCache.js | 3 +- lib/Adapters/Cache/InMemoryCacheAdapter.js | 3 +- lib/Adapters/Cache/LRUCache.js | 3 +- lib/Adapters/Cache/NullCacheAdapter.js | 3 +- lib/Adapters/Cache/RedisCacheAdapter.js | 3 +- lib/Adapters/Email/MailAdapter.js | 3 +- lib/Adapters/Files/FilesAdapter.js | 3 +- lib/Adapters/Files/GridStoreAdapter.js | 3 +- lib/Adapters/Logger/LoggerAdapter.js | 3 +- lib/Adapters/Logger/WinstonLogger.js | 3 +- lib/Adapters/Logger/WinstonLoggerAdapter.js | 3 +- lib/Adapters/MessageQueue/EventEmitterMQ.js | 3 +- lib/Adapters/PubSub/EventEmitterPubSub.js | 3 +- lib/Adapters/PubSub/RedisPubSub.js | 3 +- lib/Adapters/Push/PushAdapter.js | 3 +- lib/Adapters/Storage/Mongo/MongoCollection.js | 3 +- .../Storage/Mongo/MongoSchemaCollection.js | 3 +- .../Storage/Mongo/MongoStorageAdapter.js | 157 +- lib/Adapters/Storage/Mongo/MongoTransform.js | 132 +- .../Storage/Postgres/PostgresClient.js | 3 +- .../Storage/Postgres/PostgresConfigParser.js | 3 +- .../Postgres/PostgresStorageAdapter.js | 166 +- .../Postgres/sql/array/contains-all-regex.sql | 14 + .../Postgres/sql/array/contains-all.sql | 5 +- lib/Adapters/Storage/Postgres/sql/index.js | 4 +- lib/Adapters/Storage/StorageAdapter.js | 3 +- lib/Auth.js | 15 +- lib/ClientSDK.js | 3 +- lib/Config.js | 3 +- lib/Controllers/AdaptableController.js | 3 +- lib/Controllers/AnalyticsController.js | 3 +- lib/Controllers/CacheController.js | 3 +- lib/Controllers/DatabaseController.js | 53 +- lib/Controllers/FilesController.js | 9 +- lib/Controllers/HooksController.js | 22 +- lib/Controllers/LiveQueryController.js | 3 +- lib/Controllers/LoggerController.js | 3 +- lib/Controllers/PushController.js | 7 +- lib/Controllers/SchemaCache.js | 3 +- lib/Controllers/SchemaController.js | 7 +- lib/Controllers/UserController.js | 3 +- lib/Controllers/index.js | 8 +- lib/Controllers/types.js | 3 +- lib/LiveQuery/Client.js | 3 +- lib/LiveQuery/Id.js | 3 +- lib/LiveQuery/ParseCloudCodePublisher.js | 3 +- lib/LiveQuery/ParseLiveQueryServer.js | 3 +- lib/LiveQuery/ParsePubSub.js | 3 +- lib/LiveQuery/ParseWebSocketServer.js | 3 +- lib/LiveQuery/QueryTools.js | 3 +- lib/LiveQuery/RequestSchema.js | 3 +- lib/LiveQuery/SessionTokenCache.js | 3 +- lib/LiveQuery/Subscription.js | 3 +- lib/LiveQuery/equalObjects.js | 3 +- lib/Options/Definitions.js | 15 +- lib/Options/index.js | 3 +- lib/Options/parsers.js | 3 +- lib/ParseMessageQueue.js | 3 +- lib/ParseServer.js | 3 +- lib/ParseServerRESTController.js | 3 +- lib/PromiseRouter.js | 3 +- lib/Push/PushQueue.js | 3 +- lib/Push/PushWorker.js | 11 +- lib/Push/utils.js | 14 +- lib/RestQuery.js | 78 +- lib/RestWrite.js | 22 +- lib/Routers/AggregateRouter.js | 54 +- lib/Routers/AnalyticsRouter.js | 3 +- lib/Routers/AudiencesRouter.js | 3 +- lib/Routers/ClassesRouter.js | 8 +- lib/Routers/CloudCodeRouter.js | 3 +- lib/Routers/ExportRouter.js | 3 +- lib/Routers/FeaturesRouter.js | 3 +- lib/Routers/FilesRouter.js | 3 +- lib/Routers/FunctionsRouter.js | 6 +- lib/Routers/GlobalConfigRouter.js | 3 +- lib/Routers/HooksRouter.js | 3 +- lib/Routers/IAPValidationRouter.js | 3 +- lib/Routers/ImportRouter.js | 3 +- lib/Routers/InstallationsRouter.js | 3 +- lib/Routers/LogsRouter.js | 3 +- lib/Routers/PublicAPIRouter.js | 3 +- lib/Routers/PurgeRouter.js | 14 +- lib/Routers/PushRouter.js | 3 +- lib/Routers/RolesRouter.js | 3 +- lib/Routers/SchemasRouter.js | 3 +- lib/Routers/SessionsRouter.js | 3 +- lib/Routers/UsersRouter.js | 194 +- lib/StatusHandler.js | 3 +- lib/TestUtils.js | 12 +- lib/batch.js | 3 +- lib/cache.js | 3 +- .../definitions/parse-live-query-server.js | 3 +- lib/cli/definitions/parse-server.js | 3 +- lib/cli/parse-live-query-server.js | 3 +- lib/cli/parse-server.js | 3 +- lib/cli/utils/commander.js | 3 +- lib/cli/utils/runner.js | 3 +- lib/cloud-code/HTTPResponse.js | 3 +- lib/cloud-code/Parse.Cloud.js | 3 +- lib/cloud-code/httpRequest.js | 3 +- lib/cryptoUtils.js | 3 +- lib/defaults.js | 3 +- lib/deprecated.js | 3 +- lib/index.js | 3 +- lib/logger.js | 3 +- lib/middlewares.js | 8 +- lib/password.js | 3 +- lib/requiredParameter.js | 3 +- lib/rest.js | 43 +- lib/triggers.js | 6 +- lib/vendor/mongodbUrl.js | 3 +- package-lock.json | 12280 ++++++++++++++++ package.json | 56 +- postinstall.js | 50 + resources/npm-git.sh | 39 - spec/.babelrc | 14 + spec/AccountLockoutPolicy.spec.js | 2 +- spec/AdaptableController.spec.js | 8 +- spec/AdapterLoader.spec.js | 6 +- spec/AudienceRouter.spec.js | 8 +- spec/Auth.spec.js | 2 +- spec/AuthenticationAdapters.spec.js | 10 +- spec/CLI.spec.js | 8 +- spec/CacheController.spec.js | 2 +- spec/Client.spec.js | 4 +- spec/ClientSDK.spec.js | 2 +- spec/CloudCode.spec.js | 4 +- spec/CloudCodeLogger.spec.js | 4 +- spec/DatabaseController.spec.js | 2 +- spec/EmailVerificationToken.spec.js | 2 +- spec/EnableExpressErrorHandler.spec.js | 66 + spec/EnableSingleSchemaCache.spec.js | 6 +- spec/EventEmitterPubSub.spec.js | 2 +- spec/FilesController.spec.js | 52 +- spec/GridStoreAdapter.js | 6 +- spec/HTTPRequest.spec.js | 74 +- spec/InMemoryCache.spec.js | 4 +- spec/InMemoryCacheAdapter.spec.js | 2 +- spec/InstallationsRouter.spec.js | 8 +- spec/JobSchedule.spec.js | 4 +- spec/Logger.spec.js | 2 +- spec/LoggerController.spec.js | 10 +- spec/LogsRouter.spec.js | 6 +- spec/Middlewares.spec.js | 16 +- spec/MongoSchemaCollectionAdapter.spec.js | 2 +- spec/MongoStorageAdapter.spec.js | 8 +- spec/MongoTransform.spec.js | 39 +- spec/NullCacheAdapter.spec.js | 2 +- spec/OAuth1.spec.js | 2 +- spec/ParseACL.spec.js | 6 +- spec/ParseAPI.spec.js | 30 +- spec/ParseCloudCodePublisher.spec.js | 8 +- spec/ParseFile.spec.js | 18 - spec/ParseGeoPoint.spec.js | 110 + spec/ParseGlobalConfig.spec.js | 2 +- spec/ParseHooks.spec.js | 24 +- spec/ParseInstallation.spec.js | 8 +- spec/ParseLiveQueryServer.spec.js | 117 +- spec/ParseObject.spec.js | 27 + spec/ParsePolygon.spec.js | 263 +- spec/ParsePubSub.spec.js | 34 +- spec/ParseQuery.Aggregate.spec.js | 306 +- spec/ParseQuery.FullTextSearch.spec.js | 8 +- spec/ParseQuery.spec.js | 867 +- spec/ParseRelation.spec.js | 33 + spec/ParseRole.spec.js | 6 +- spec/ParseServer.spec.js | 23 +- spec/ParseServerRESTController.spec.js | 4 +- spec/ParseUser.spec.js | 238 +- spec/ParseWebSocket.spec.js | 2 +- spec/ParseWebSocketServer.spec.js | 2 +- spec/PointerPermissions.spec.js | 2 +- spec/PostgresConfigParser.spec.js | 2 +- spec/PostgresInitOptions.spec.js | 16 +- spec/PostgresStorageAdapter.spec.js | 2 +- spec/PromiseRouter.spec.js | 2 +- spec/PushController.spec.js | 86 +- spec/PushQueue.spec.js | 4 +- spec/PushRouter.spec.js | 2 +- spec/PushWorker.spec.js | 14 +- spec/QueryTools.spec.js | 4 +- spec/ReadPreferenceOption.spec.js | 65 +- spec/RedisCacheAdapter.spec.js | 2 +- spec/RedisPubSub.spec.js | 2 +- spec/RestQuery.spec.js | 6 +- spec/RevocableSessionsUpgrade.spec.js | 2 +- spec/Schema.spec.js | 4 +- spec/SchemaCache.spec.js | 6 +- spec/SessionTokenCache.spec.js | 2 +- spec/Subscription.spec.js | 4 +- spec/TwitterAuth.spec.js | 2 +- spec/Uniqueness.spec.js | 2 +- spec/UserController.spec.js | 4 +- spec/UserPII.spec.js | 2 +- spec/ValidationAndPasswordsReset.spec.js | 2 +- spec/VerifyUserPassword.spec.js | 494 + spec/WinstonLoggerAdapter.spec.js | 2 +- spec/batch.spec.js | 2 +- spec/cryptoUtils.spec.js | 2 +- spec/helper.js | 46 +- spec/index.spec.js | 6 +- spec/parsers.spec.js | 4 +- spec/rest.spec.js | 8 +- spec/schemas.spec.js | 925 +- spec/support/jasmine.json | 1 - spec/testing-routes.js | 10 +- src/Adapters/Auth/facebook.js | 2 +- src/Adapters/Auth/vkontakte.js | 2 +- .../Storage/Mongo/MongoStorageAdapter.js | 157 +- src/Adapters/Storage/Mongo/MongoTransform.js | 150 +- .../Postgres/PostgresStorageAdapter.js | 202 +- .../Postgres/sql/array/contains-all-regex.sql | 14 + .../Postgres/sql/array/contains-all.sql | 5 +- src/Adapters/Storage/Postgres/sql/index.js | 1 + src/Adapters/Storage/StorageAdapter.js | 4 +- src/Auth.js | 12 +- src/Controllers/DatabaseController.js | 52 +- src/Controllers/FilesController.js | 8 +- src/Controllers/HooksController.js | 11 +- src/Controllers/PushController.js | 5 +- src/Controllers/SchemaController.js | 4 +- src/Controllers/index.js | 6 +- src/Options/Definitions.js | 12 + src/Options/index.js | 5 + src/Push/PushWorker.js | 14 +- src/Push/utils.js | 15 +- src/RestQuery.js | 77 +- src/RestWrite.js | 18 +- src/Routers/AggregateRouter.js | 102 +- src/Routers/ClassesRouter.js | 5 +- src/Routers/FunctionsRouter.js | 3 + src/Routers/PurgeRouter.js | 6 + src/Routers/UsersRouter.js | 224 +- src/TestUtils.js | 9 +- src/middlewares.js | 5 +- src/rest.js | 40 +- src/triggers.js | 3 + 273 files changed, 17936 insertions(+), 1684 deletions(-) create mode 100644 .github/ISSUE_TEMPLATE/---feature-request.md create mode 100644 .github/ISSUE_TEMPLATE/---push-notifications.md create mode 100644 .github/ISSUE_TEMPLATE/---report-an-issue.md create mode 100644 .github/ISSUE_TEMPLATE/Bug_report.md create mode 100644 .nvmrc create mode 100644 lib/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql create mode 100644 package-lock.json create mode 100644 postinstall.js delete mode 100755 resources/npm-git.sh create mode 100644 spec/.babelrc create mode 100644 spec/EnableExpressErrorHandler.spec.js create mode 100644 spec/VerifyUserPassword.spec.js create mode 100644 src/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql diff --git a/.babelrc b/.babelrc index 509c3decfe..c8c8069f1d 100644 --- a/.babelrc +++ b/.babelrc @@ -6,8 +6,9 @@ "presets": [ ["env", { "targets": { - "node": "6.11.4" + "node": "8" } }] - ] + ], + "sourceMaps": "inline" } diff --git a/.github/ISSUE_TEMPLATE/---feature-request.md b/.github/ISSUE_TEMPLATE/---feature-request.md new file mode 100644 index 0000000000..a19d228731 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/---feature-request.md @@ -0,0 +1,17 @@ +--- +name: "\U0001F4A1 Feature request" +about: Suggest an idea for this project + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/ISSUE_TEMPLATE/---push-notifications.md b/.github/ISSUE_TEMPLATE/---push-notifications.md new file mode 100644 index 0000000000..3466cb9c1d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/---push-notifications.md @@ -0,0 +1,7 @@ +--- +name: "\U0001F4F2 Push Notifications" +about: Issues with setting up or delivering push notifications + +--- + + diff --git a/.github/ISSUE_TEMPLATE/---report-an-issue.md b/.github/ISSUE_TEMPLATE/---report-an-issue.md new file mode 100644 index 0000000000..b5bdc244a4 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/---report-an-issue.md @@ -0,0 +1,53 @@ +--- +name: "\U0001F41B Report an issue" +about: Report an issue on parse-server + +--- + + +### Issue Description + + + +### Steps to reproduce + + + +### Expected Results + + + +### Actual Outcome + + + +### Environment Setup + +- **Server** + - parse-server version (Be specific! Don't say 'latest'.) : [FILL THIS OUT] + - Operating System: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, Heroku, Azure, Digital Ocean, etc): [FILL THIS OUT] + +- **Database** + - MongoDB version: [FILL THIS OUT] + - Storage engine: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, mLab, ObjectRocket, Digital Ocean, etc): [FILL THIS OUT] + +### Logs/Trace + + diff --git a/.github/ISSUE_TEMPLATE/Bug_report.md b/.github/ISSUE_TEMPLATE/Bug_report.md new file mode 100644 index 0000000000..9e9c19e399 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/Bug_report.md @@ -0,0 +1,51 @@ +--- +name: Report an issue +about: Report an issue on parse-server + +--- + +We use GitHub Issues for bugs. + +If you have a non-bug question, ask on Stack Overflow or Server Fault: +- https://stackoverflow.com/questions/tagged/parse.com +- https://serverfault.com/tags/parse + +If you have a vulnerability disclosure, please follow our policy available here https://github.com/parse-community/parse-server/blob/master/SECURITY.md + +You may also search through existing issues before opening a new one: https://github.com/parse-community/parse-server/issues?utf8=%E2%9C%93&q=is%3Aissue + +--- Please use this template. If you don't use this template, your issue may be closed without comment. --- + +### Issue Description + +Describe your issue in as much detail as possible. + +### Steps to reproduce + +Please include a detailed list of steps that reproduce the issue. Include curl commands when applicable. + +#### Expected Results + +What you expected to happen. + +#### Actual Outcome + +What is happening instead. + +### Environment Setup + +- **Server** + - parse-server version (Be specific! Don't say 'latest'.) : [FILL THIS OUT] + - Operating System: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, Heroku, Azure, Digital Ocean, etc): [FILL THIS OUT] + +- **Database** + - MongoDB version: [FILL THIS OUT] + - Storage engine: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, mLab, ObjectRocket, Digital Ocean, etc): [FILL THIS OUT] + +### Logs/Trace + +Include all relevant logs. You can turn on additional logging by configuring VERBOSE=1 in your environment. diff --git a/.gitignore b/.gitignore index 8f1edaabbf..fa194e2576 100644 --- a/.gitignore +++ b/.gitignore @@ -52,3 +52,6 @@ node_modules # Folder created by FileSystemAdapter /files + +# Merge files +*.orig diff --git a/.nvmrc b/.nvmrc new file mode 100644 index 0000000000..22ec1e6494 --- /dev/null +++ b/.nvmrc @@ -0,0 +1 @@ +8.10 diff --git a/.nycrc b/.nycrc index 60afab1c96..4233221321 100644 --- a/.nycrc +++ b/.nycrc @@ -5,7 +5,7 @@ ], "exclude": [ "**/spec/**", - "lib/" + "src/" ] } diff --git a/.travis.yml b/.travis.yml index 156719debc..3c6cb081ec 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,8 +7,9 @@ services: - docker addons: postgresql: '9.5' - apt_packages: - - postgresql-9.5-postgis-2.3 + apt: + packages: + - postgresql-9.5-postgis-2.3 branches: only: - master @@ -25,44 +26,43 @@ stage: test env: global: - COVERAGE_OPTION='./node_modules/.bin/nyc' - - NODE_VERSION=6.11.4 + - NODE_VERSION=8.11.2 matrix: - MONGODB_VERSION=3.2.13 - MONGODB_VERSION=3.4.4 - PARSE_SERVER_TEST_DB=postgres - PARSE_SERVER_TEST_CACHE=redis - - NODE_VERSION=8.7 + - NODE_VERSION=stable +matrix: + allow_failures: + - env: NODE_VERSION=stable before_install: - nvm install $NODE_VERSION - nvm use $NODE_VERSION +- npm install -g greenkeeper-lockfile@1 before_script: - node -e 'require("./lib/index.js")' - psql -c 'create database parse_server_postgres_adapter_test_database;' -U postgres - psql -c 'CREATE EXTENSION postgis;' -U postgres -d parse_server_postgres_adapter_test_database - psql -c 'CREATE EXTENSION postgis_topology;' -U postgres -d parse_server_postgres_adapter_test_database - silent=1 mongodb-runner --start +- greenkeeper-lockfile-update script: - npm run coverage after_script: +- greenkeeper-lockfile-upload - bash <(curl -s https://codecov.io/bash) jobs: include: - # release on github latest branch + # release on npm on tags - stage: release - node_js: '6.11.4' + node_js: '8.10' env: before_script: skip after_script: skip script: skip deploy: - - provider: script - skip_cleanup: true - script: ./resources/npm-git.sh - on: - branch: - - master - - 3.x - provider: npm skip_cleanup: true email: diff --git a/CHANGELOG.md b/CHANGELOG.md index dedd655d06..f311531762 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,117 @@ ## Parse Server Changelog ### master -[Full Changelog](https://github.com/parse-community/parse-server/compare/2.7.4...master) +[Full Changelog](https://github.com/parse-community/parse-server/compare/2.8.4...master) + +### 2.8.4 +[Full Changelog](https://github.com/parse-community/parse-server/compare/2.8.3...2.8.4) + +#### Improvements +* Adds ability to forward errors to express handler (#4697) +* Adds ability to increment the push badge with an arbitrary value (#4889) +* Adds ability to preserve the file names when uploading (#4915) +* `_User` now follow regular ACL policy. Letting administrator lock user out. (#4860) and (#4898) +* Ensure dates are properly handled in aggregates (#4743) +* Aggregates: Improved support for stages sharing the same name +* Add includeAll option +* Added verify password to users router and tests. (#4747) +* Ensure read preference is never overriden, so DB config prevails (#4833) +* add support for geoWithin.centerSphere queries via withJSON (#4825) +* Allow sorting an object field (#4806) +* Postgres: Don't merge JSON fields after save() to keep same behaviour as MongoDB (#4808) (#4815) + +#### Dependency updates +* [commander@2.16.0](https://www.npmjs.com/package/commander) +* [mongodb@3.1.1](https://www.npmjs.com/package/mongodb) +* [pg-promise@8.4.5](https://www.npmjs.com/package/pg-promise) +* [ws@6.0.0](https://www.npmjs.com/package/ws) +* [bcrypt@3.0.0](https://www.npmjs.com/package/bcrypt) +* [uws@10.148.1](https://www.npmjs.com/package/uws) + +##### Devevelopment Dependencies Updates: +* [cross-env@5.2.0](https://www.npmjs.com/package/cross-env) +* [eslint@5.0.0](https://www.npmjs.com/package/eslint) +* [flow-bin@0.76.0](https://www.npmjs.com/package/flow-bin) +* [mongodb-runner@4.0.0](https://www.npmjs.com/package/mongodb-runner) +* [nodemon@1.18.1](https://www.npmjs.com/package/nodemon) +* [nyc@12.0.2](https://www.npmjs.com/package/nyc) +* [request-promise@4.2.2](https://www.npmjs.com/package/request-promise) +* [supports-color@5.4.0](https://www.npmjs.com/package/supports-color) + +### 2.8.3 +[Full Changelog](https://github.com/parse-community/parse-server/compare/2.8.2...2.8.3) + +* Adds support for JS SDK 2.0 job status header + +### 2.8.2 +[Full Changelog](https://github.com/parse-community/parse-server/compare/2.8.1...2.8.2) + +##### Bug Fixes: +* Ensure legacy users without ACL's are not locked out, thanks to [Florent Vilmart](https://github.com/flovilmart) + +#### Improvements: +* Use common HTTP agent to increase webhooks performance, thanks to [Tyler Brock](https://github.com/TylerBrock) +* Adds withinPolygon support for Polygon objects, thanks to [Mads Bjerre](https://github.com/madsb) + +#### Dependency Updates: +* [ws@5.2.0](https://www.npmjs.com/package/ws) +* [commander@2.15.1](https://www.npmjs.com/package/commander) +* [nodemon@1.17.5](https://www.npmjs.com/package/nodemon) + +##### Devevelopment Dependencies Updates: +* [flow-bin@0.73.0](https://www.npmjs.com/package/flow-bin) +* [cross-env@5.1.6](https://www.npmjs.com/package/cross-env) +* [gaze@1.1.3](https://www.npmjs.com/package/gaze) +* [deepcopy@1.0.0](https://www.npmjs.com/package/deepcopy) +* [deep-diff@1.0.1](https://www.npmjs.com/package/deep-diff) + + +### 2.8.1 +[Full Changelog](https://github.com/parse-community/parse-server/compare/2.8.1...2.8.0) + +Ensure all the files are properly exported to the final package. + +### 2.8.0 +[Full Changelog](https://github.com/parse-community/parse-server/compare/2.8.0...2.7.4) + +#### New Features +* Adding Mongodb element to add `arrayMatches` the #4762 (#4766), thanks to [Jérémy Piednoel](https://github.com/jeremypiednoel) +* Adds ability to Lockout users (#4749), thanks to [Florent Vilmart](https://github.com/flovilmart) + +#### Bug fixes: +* Fixes issue when using afterFind with relations (#4752), thanks to [Florent Vilmart](https://github.com/flovilmart) +* New query condition support to match all strings that starts with some other given strings (#3864), thanks to [Eduard Bosch Bertran](https://github.com/eduardbosch) +* Allow creation of indices on default fields (#4738), thanks to [Claire Neveu](https://github.com/ClaireNeveu) +* Purging empty class (#4676), thanks to [Diamond Lewis](https://github.com/dplewis) +* Postgres: Fixes issues comparing to zero or false (#4667), thanks to [Diamond Lewis](https://github.com/dplewis) +* Fix Aggregate Match Pointer (#4643), thanks to [Diamond Lewis](https://github.com/dplewis) + +#### Improvements: +* Allow Parse.Error when returning from Cloud Code (#4695), thanks to [Saulo Tauil](https://github.com/saulogt) +* Fix typo: "requrest" -> "request" (#4761), thanks to [Joseph Frazier](https://github.com/josephfrazier) +* Send version for Vkontakte API (#4725), thanks to [oleg](https://github.com/alekoleg) +* Ensure we respond with invalid password even if email is unverified (#4708), thanks to [dblythy](https://github.com/dblythy) +* Add _password_history to default sensitive data (#4699), thanks to [Jong Eun Lee](https://github.com/yomybaby) +* Check for node version in postinstall script (#4657), thanks to [Diamond Lewis](https://github.com/dplewis) +* Remove FB Graph API version from URL to use the oldest non deprecated version, thanks to [SebC](https://github.com/SebC99) + +#### Dependency Updates: +* [@parse/push-adapter@2.0.3](https://www.npmjs.com/package/@parse/push-adapter) +* [@parse/simple-mailgun-adapter@1.0.2](https://www.npmjs.com/package/@parse/simple-mailgun-adapter) +* [uws@10.148.0](https://www.npmjs.com/package/uws) +* [body-parser@1.18.3](https://www.npmjs.com/package/body-parser) +* [mime@2.3.1](https://www.npmjs.com/package/mime) +* [request@2.85.0](https://www.npmjs.com/package/request) +* [mongodb@3.0.7](https://www.npmjs.com/package/mongodb) +* [bcrypt@2.0.1](https://www.npmjs.com/package/bcrypt) +* [ws@5.1.1](https://www.npmjs.com/package/ws) + +##### Devevelopment Dependencies Updates: +* [cross-env@5.1.5](https://www.npmjs.com/package/cross-env) +* [flow-bin@0.71.0](https://www.npmjs.com/package/flow-bin) +* [deep-diff@1.0.0](https://www.npmjs.com/package/deep-diff) +* [nodemon@1.17.3](https://www.npmjs.com/package/nodemon) + ### 2.7.4 [Full Changelog](https://github.com/parse-community/parse-server/compare/2.7.4...2.7.3) @@ -1079,7 +1189,7 @@ Other fixes by [Mathias Rangel Wulff](https://github.com/mathiasrw) * Fix: Improve compatability of cloud code beforeSave hook for newly created object * Fix: ACL creation for master key only objects * Fix: Allow uploading files without Content-Type -* Fix: Add features to http requrest to match Parse.com +* Fix: Add features to http request to match Parse.com * Fix: Bugs in development script when running from locations other than project root * Fix: Can pass query constraints in URL * Fix: Objects with legacy "_tombstone" key now don't cause issues. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f6a907f832..6f822ae0ce 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,10 +1,49 @@ -### Contributing to Parse Server +# Contributing to Parse Server -#### Pull Requests Welcome! +We really want Parse to be yours, to see it grow and thrive in the open source community. -We really want Parse to be yours, to see it grow and thrive in the open source community. +If you are not familiar with Pull Requests and want to know more about them, you can visit the [Creating a pull request](https://help.github.com/articles/creating-a-pull-request/) article. It contains detailed informations about the process. -##### Please Do's +## Setting up the project for debugging and contributing: + +### Recommended setup: + +* [vscode](https://code.visualstudio.com), the popular IDE. +* [Jasmine Test Explorer](https://marketplace.visualstudio.com/items?itemName=hbenl.vscode-test-explorer), a very practical test exploration plugin which let you run, debug and see the test results inline. + +### Setting up you local machine: + +* [Fork](https://github.com/parse-community/parse-server) this project and clone the fork on your local machine: + +```sh +$ git clone https://github.com/parse-community/parse-server +$ cd parse-server # go into the clone directory +$ npm install # install all the node dependencies +$ code . # launch vscode +$ npm run watch # run babel watching for local file changes +``` + +Once you have babel running in watch mode, you can start making changes to parse-server. + +### Good to know: + +* The lib/ folder is not commited, so never make changes in there. +* Always make changes to files in the `src/` folder. +* All the tests should point to sources in the `lib/` folder. + +### Troubleshooting: + +*Question*: I modify the code in the src folder but it doesn't seem to have any effect.
+*Answer*: Check that `npm run watch` is running + +*Question*: How do I use breakpoints and debug step by step?
+*Answer*: The easiest way is to install [Jasmine Test Explorer](https://marketplace.visualstudio.com/items?itemName=hbenl.vscode-test-explorer), it will let you run selectively tests and debug them. + +*Question*: How do I deploy my forked version on my servers?
+*Answer*: In your `package.json`, update the `parse-server` dependency to `https://github.com/MY_USERNAME/parse-server#MY_FEATURE`. Run `npm install`, commit the changes and deploy to your servers. + + +### Please Do's * Begin by reading the [Development Guide](http://docs.parseplatform.org/parse-server/guide/#development-guide) to learn how to get started running the parse-server. * Take testing seriously! Aim to increase the test coverage with every pull request. To obtain the test coverage of the project, run: @@ -17,7 +56,7 @@ We really want Parse to be yours, to see it grow and thrive in the open source c * Lint your code by running `npm run lint` to make sure the code is not going to be rejected by the CI. * **Do not** publish the *lib* folder. -##### Run your tests against Postgres (optional) +### Run your tests against Postgres (optional) If your pull request introduces a change that may affect the storage or retrieval of objects, you may want to make sure it plays nice with Postgres. @@ -28,6 +67,6 @@ If your pull request introduces a change that may affect the storage or retrieva - `it_only_db('mongo')` // will make a test that only runs on mongo - `it_exclude_dbs(['postgres'])` // will make a test that runs against all DB's but postgres -##### Code of Conduct +### Code of Conduct This project adheres to the [Contributor Covenant Code of Conduct](https://github.com/parse-community/parse-server/blob/master/CODE_OF_CONDUCT.md). By participating, you are expected to honor this code. diff --git a/Dockerfile b/Dockerfile index bf30a303d1..b4ac513b58 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM node:boron +FROM node:carbon RUN mkdir -p /parse-server COPY ./ /parse-server/ diff --git a/README.md b/README.md index 0b6a2ea132..3c5a81bea3 100644 --- a/README.md +++ b/README.md @@ -232,6 +232,7 @@ The client keys used with Parse are no longer necessary with Parse Server. If yo #### Advanced options * `fileKey` - For migrated apps, this is necessary to provide access to files already hosted on Parse. +* `preserveFileName` - Set to true to remove the unique hash added to the file names. Defaults to false. * `allowClientClassCreation` - Set to false to disable client class creation. Defaults to true. * `enableAnonymousUsers` - Set to false to disable anonymous users. Defaults to true. * `auth` - Used to configure support for [3rd party authentication](http://docs.parseplatform.org/parse-server/guide/#oauth-and-3rd-party-authentication). @@ -393,16 +394,24 @@ If you believe you've found an issue with Parse Server, make sure these boxes ar # Want to ride the bleeding edge? -The `latest` branch in this repository is automatically maintained to be the last -commit to `master` to pass all tests, in the same form found on npm. It is -recommend to use builds deployed npm for many reasons, but if you want to use +It is recommend to use builds deployed npm for many reasons, but if you want to use the latest not-yet-released version of parse-server, you can do so by depending directly on this branch: ``` -npm install parseplatform/parse-server.git#latest +npm install parse-community/parse-server.git#master ``` +## Experimenting + +You can also use your own forks, and work in progress branches by specifying them: + +``` +npm install github:myUsername/parse-server#my-awesome-feature +``` + +And don't forget, if you plan to deploy it remotely, you should run `npm install` with the `--save` option. + # Contributing We really want Parse to be yours, to see it grow and thrive in the open source community. Please see the [Contributing to Parse Server guide](CONTRIBUTING.md). diff --git a/lib/AccountLockout.js b/lib/AccountLockout.js index dd1522e9c7..3c16140231 100644 --- a/lib/AccountLockout.js +++ b/lib/AccountLockout.js @@ -156,4 +156,5 @@ class AccountLockout { exports.AccountLockout = AccountLockout; // This class handles the Account Lockout Policy settings. -exports.default = AccountLockout; \ No newline at end of file +exports.default = AccountLockout; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/AccountLockout.js"],"names":["AccountLockout","constructor","user","config","_user","_config","_setFailedLoginCount","value","query","username","updateFields","_failed_login_count","database","update","_isFailedLoginCountSet","$exists","find","then","users","Array","isArray","length","_initFailedLoginCount","failedLoginCountIsSet","_incrementFailedLoginCount","__op","amount","_setLockoutExpiration","$gte","accountLockout","threshold","now","Date","_account_lockout_expires_at","Parse","_encode","getTime","duration","catch","err","code","message","_notLocked","$gt","Error","OBJECT_NOT_FOUND","_handleFailedLoginAttempt","handleLoginAttempt","loginSuccessful","Promise","resolve"],"mappings":"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","file":"AccountLockout.js","sourcesContent":["// This class handles the Account Lockout Policy settings.\nimport Parse from 'parse/node';\n\nexport class AccountLockout {\n  constructor(user, config) {\n    this._user = user;\n    this._config = config;\n  }\n\n  /**\n   * set _failed_login_count to value\n   */\n  _setFailedLoginCount(value) {\n    const query = {\n      username: this._user.username\n    };\n\n    const updateFields = {\n      _failed_login_count: value\n    };\n\n    return this._config.database.update('_User', query, updateFields);\n  }\n\n  /**\n   * check if the _failed_login_count field has been set\n   */\n  _isFailedLoginCountSet() {\n    const query = {\n      username: this._user.username,\n      _failed_login_count: { $exists: true }\n    };\n\n    return this._config.database.find('_User', query)\n      .then(users => {\n        if (Array.isArray(users) && users.length > 0) {\n          return true;\n        } else {\n          return false;\n        }\n      });\n  }\n\n  /**\n   * if _failed_login_count is NOT set then set it to 0\n   * else do nothing\n   */\n  _initFailedLoginCount() {\n    return this._isFailedLoginCountSet()\n      .then(failedLoginCountIsSet => {\n        if (!failedLoginCountIsSet) {\n          return this._setFailedLoginCount(0);\n        }\n      });\n  }\n\n  /**\n   * increment _failed_login_count by 1\n   */\n  _incrementFailedLoginCount() {\n    const query = {\n      username: this._user.username\n    };\n\n    const updateFields = {_failed_login_count: {__op: 'Increment', amount: 1}};\n\n    return this._config.database.update('_User', query, updateFields);\n  }\n\n  /**\n   * if the failed login count is greater than the threshold\n   * then sets lockout expiration to 'currenttime + accountPolicy.duration', i.e., account is locked out for the next 'accountPolicy.duration' minutes\n   * else do nothing\n   */\n  _setLockoutExpiration() {\n    const query = {\n      username: this._user.username,\n      _failed_login_count: { $gte: this._config.accountLockout.threshold }\n    };\n\n    const now = new Date();\n\n    const updateFields = {\n      _account_lockout_expires_at: Parse._encode(new Date(now.getTime() + this._config.accountLockout.duration * 60 * 1000))\n    };\n\n    return this._config.database.update('_User', query, updateFields)\n      .catch(err => {\n        if (err && err.code && err.message && err.code === 101 && err.message === 'Object not found.') {\n          return; // nothing to update so we are good\n        } else {\n          throw err; // unknown error\n        }\n      });\n  }\n\n  /**\n   * if _account_lockout_expires_at > current_time and _failed_login_count > threshold\n   *   reject with account locked error\n   * else\n   *   resolve\n   */\n  _notLocked() {\n    const query = {\n      username: this._user.username,\n      _account_lockout_expires_at: { $gt: Parse._encode(new Date()) },\n      _failed_login_count: {$gte: this._config.accountLockout.threshold}\n    };\n\n    return this._config.database.find('_User', query)\n      .then(users => {\n        if (Array.isArray(users) && users.length > 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Your account is locked due to multiple failed login attempts. Please try again after ' + this._config.accountLockout.duration + ' minute(s)');\n        }\n      });\n  }\n\n  /**\n   * set and/or increment _failed_login_count\n   * if _failed_login_count > threshold\n   *   set the _account_lockout_expires_at to current_time + accountPolicy.duration\n   * else\n   *   do nothing\n   */\n  _handleFailedLoginAttempt() {\n    return this._initFailedLoginCount()\n      .then(() => {\n        return this._incrementFailedLoginCount();\n      })\n      .then(() => {\n        return this._setLockoutExpiration();\n      });\n  }\n\n  /**\n   * handle login attempt if the Account Lockout Policy is enabled\n   */\n  handleLoginAttempt(loginSuccessful) {\n    if (!this._config.accountLockout) {\n      return Promise.resolve();\n    }\n    return this._notLocked()\n      .then(() => {\n        if (loginSuccessful) {\n          return this._setFailedLoginCount(0);\n        } else {\n          return this._handleFailedLoginAttempt();\n        }\n      });\n  }\n\n}\n\nexport default AccountLockout;\n"]} \ No newline at end of file diff --git a/lib/Adapters/AdapterLoader.js b/lib/Adapters/AdapterLoader.js index ffdf98fd95..9dd1852e55 100644 --- a/lib/Adapters/AdapterLoader.js +++ b/lib/Adapters/AdapterLoader.js @@ -41,4 +41,5 @@ function loadAdapter(adapter, defaultAdapter, options) { return adapter; } -exports.default = loadAdapter; \ No newline at end of file +exports.default = loadAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Analytics/AnalyticsAdapter.js b/lib/Adapters/Analytics/AnalyticsAdapter.js index d4af892ac0..ba26cf0606 100644 --- a/lib/Adapters/Analytics/AnalyticsAdapter.js +++ b/lib/Adapters/Analytics/AnalyticsAdapter.js @@ -25,4 +25,5 @@ class AnalyticsAdapter { } exports.AnalyticsAdapter = AnalyticsAdapter; -exports.default = AnalyticsAdapter; \ No newline at end of file +exports.default = AnalyticsAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BbmFseXRpY3MvQW5hbHl0aWNzQWRhcHRlci5qcyJdLCJuYW1lcyI6WyJBbmFseXRpY3NBZGFwdGVyIiwiYXBwT3BlbmVkIiwicGFyYW1ldGVycyIsInJlcSIsIlByb21pc2UiLCJyZXNvbHZlIiwidHJhY2tFdmVudCIsImV2ZW50TmFtZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQUNPLE1BQU1BLGdCQUFOLENBQXVCOztBQUU1Qjs7OztBQUlBQyxZQUFVQyxVQUFWLEVBQXNCQyxHQUF0QixFQUEyQjtBQUN6QixXQUFPQyxRQUFRQyxPQUFSLENBQWdCLEVBQWhCLENBQVA7QUFDRDs7QUFFRDs7Ozs7QUFLQUMsYUFBV0MsU0FBWCxFQUFzQkwsVUFBdEIsRUFBa0NDLEdBQWxDLEVBQXVDO0FBQ3JDLFdBQU9DLFFBQVFDLE9BQVIsQ0FBZ0IsRUFBaEIsQ0FBUDtBQUNEO0FBakIyQjs7UUFBakJMLGdCLEdBQUFBLGdCO2tCQW9CRUEsZ0IiLCJmaWxlIjoiQW5hbHl0aWNzQWRhcHRlci5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qZXNsaW50IG5vLXVudXNlZC12YXJzOiBcIm9mZlwiKi9cbmV4cG9ydCBjbGFzcyBBbmFseXRpY3NBZGFwdGVyIHtcblxuICAvKlxuICBAcGFyYW0gcGFyYW1ldGVyczogdGhlIGFuYWx5dGljcyByZXF1ZXN0IGJvZHksIGFuYWx5dGljcyBpbmZvIHdpbGwgYmUgaW4gdGhlIGRpbWVuc2lvbnMgcHJvcGVydHlcbiAgQHBhcmFtIHJlcTogdGhlIG9yaWdpbmFsIGh0dHAgcmVxdWVzdFxuICAgKi9cbiAgYXBwT3BlbmVkKHBhcmFtZXRlcnMsIHJlcSkge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoe30pO1xuICB9XG5cbiAgLypcbiAgQHBhcmFtIGV2ZW50TmFtZTogdGhlIG5hbWUgb2YgdGhlIGN1c3RvbSBldmVudE5hbWVcbiAgQHBhcmFtIHBhcmFtZXRlcnM6IHRoZSBhbmFseXRpY3MgcmVxdWVzdCBib2R5LCBhbmFseXRpY3MgaW5mbyB3aWxsIGJlIGluIHRoZSBkaW1lbnNpb25zIHByb3BlcnR5XG4gIEBwYXJhbSByZXE6IHRoZSBvcmlnaW5hbCBodHRwIHJlcXVlc3RcbiAgICovXG4gIHRyYWNrRXZlbnQoZXZlbnROYW1lLCBwYXJhbWV0ZXJzLCByZXEpIHtcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHt9KTtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBBbmFseXRpY3NBZGFwdGVyO1xuIl19 \ No newline at end of file diff --git a/lib/Adapters/Auth/AuthAdapter.js b/lib/Adapters/Auth/AuthAdapter.js index b3dec519db..6c4ea0972a 100644 --- a/lib/Adapters/Auth/AuthAdapter.js +++ b/lib/Adapters/Auth/AuthAdapter.js @@ -25,4 +25,5 @@ class AuthAdapter { } exports.AuthAdapter = AuthAdapter; -exports.default = AuthAdapter; \ No newline at end of file +exports.default = AuthAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BdXRoL0F1dGhBZGFwdGVyLmpzIl0sIm5hbWVzIjpbIkF1dGhBZGFwdGVyIiwidmFsaWRhdGVBcHBJZCIsImFwcElkcyIsImF1dGhEYXRhIiwiUHJvbWlzZSIsInJlc29sdmUiLCJ2YWxpZGF0ZUF1dGhEYXRhIiwib3B0aW9ucyJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQUNPLE1BQU1BLFdBQU4sQ0FBa0I7O0FBRXZCOzs7OztBQUtBQyxnQkFBY0MsTUFBZCxFQUFzQkMsUUFBdEIsRUFBZ0M7QUFDOUIsV0FBT0MsUUFBUUMsT0FBUixDQUFnQixFQUFoQixDQUFQO0FBQ0Q7O0FBRUQ7Ozs7QUFJQUMsbUJBQWlCSCxRQUFqQixFQUEyQkksT0FBM0IsRUFBb0M7QUFDbEMsV0FBT0gsUUFBUUMsT0FBUixDQUFnQixFQUFoQixDQUFQO0FBQ0Q7QUFqQnNCOztRQUFaTCxXLEdBQUFBLFc7a0JBb0JFQSxXIiwiZmlsZSI6IkF1dGhBZGFwdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyplc2xpbnQgbm8tdW51c2VkLXZhcnM6IFwib2ZmXCIqL1xuZXhwb3J0IGNsYXNzIEF1dGhBZGFwdGVyIHtcblxuICAvKlxuICBAcGFyYW0gYXBwSWRzOiB0aGUgc3BlY2lmaWVkIGFwcCBpZHMgaW4gdGhlIGNvbmZpZ3VyYXRpb25cbiAgQHBhcmFtIGF1dGhEYXRhOiB0aGUgY2xpZW50IHByb3ZpZGVkIGF1dGhEYXRhXG4gIEByZXR1cm5zIGEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIGlmIHRoZSBhcHBsaWNhdGlvbklkIGlzIHZhbGlkXG4gICAqL1xuICB2YWxpZGF0ZUFwcElkKGFwcElkcywgYXV0aERhdGEpIHtcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHt9KTtcbiAgfVxuXG4gIC8qXG4gIEBwYXJhbSBhdXRoRGF0YTogdGhlIGNsaWVudCBwcm92aWRlZCBhdXRoRGF0YVxuICBAcGFyYW0gb3B0aW9uczogYWRkaXRpb25hbCBvcHRpb25zXG4gICAqL1xuICB2YWxpZGF0ZUF1dGhEYXRhKGF1dGhEYXRhLCBvcHRpb25zKSB7XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSh7fSk7XG4gIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgQXV0aEFkYXB0ZXI7XG4iXX0= \ No newline at end of file diff --git a/lib/Adapters/Auth/OAuth1Client.js b/lib/Adapters/Auth/OAuth1Client.js index 68da0c6f99..5d719f7c1d 100644 --- a/lib/Adapters/Auth/OAuth1Client.js +++ b/lib/Adapters/Auth/OAuth1Client.js @@ -219,4 +219,5 @@ OAuth.signRequest = function (request, oauth_parameters, consumer_secret, auth_t return request; }; -module.exports = OAuth; \ No newline at end of file +module.exports = OAuth; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Adapters/Auth/OAuth1Client.js"],"names":["https","require","crypto","Parse","OAuth","options","Error","INTERNAL_SERVER_ERROR","consumer_key","consumer_secret","auth_token","auth_token_secret","host","oauth_params","prototype","send","method","path","params","body","request","buildRequest","Promise","resolve","reject","httpRequest","res","data","on","chunk","JSON","parse","write","end","indexOf","Object","keys","length","buildParameterString","toUpperCase","oauth_consumer_key","signRequest","get","post","encode","str","toString","encodeURIComponent","replace","signatureMethod","version","nonce","text","possible","i","charAt","Math","floor","random","obj","sort","map","key","join","buildSignatureString","url","parameters","signature","createHmac","update","digest","oauth_parameters","oauth_nonce","oauth_timestamp","Date","getTime","oauth_signature_method","oauth_version","signatureParams","parametersToMerge","k","parameterString","signatureString","signatureKey","oauth_signature","headers","authHeader","value","Authorization","module","exports"],"mappings":"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","file":"OAuth1Client.js","sourcesContent":["var https = require('https'),\n  crypto = require('crypto');\nvar Parse = require('parse/node').Parse;\n\nvar OAuth = function(options) {\n  if(!options) {\n    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'No options passed to OAuth');\n  }\n  this.consumer_key = options.consumer_key;\n  this.consumer_secret = options.consumer_secret;\n  this.auth_token = options.auth_token;\n  this.auth_token_secret = options.auth_token_secret;\n  this.host = options.host;\n  this.oauth_params = options.oauth_params || {};\n};\n\nOAuth.prototype.send = function(method, path, params, body){\n\n  var request = this.buildRequest(method, path, params, body);\n  // Encode the body properly, the current Parse Implementation don't do it properly\n  return new Promise(function(resolve, reject) {\n    var httpRequest = https.request(request, function(res) {\n      var data = '';\n      res.on('data', function(chunk) {\n        data += chunk;\n      });\n      res.on('end', function() {\n        data = JSON.parse(data);\n        resolve(data);\n      });\n    }).on('error', function() {\n      reject('Failed to make an OAuth request');\n    });\n    if (request.body) {\n      httpRequest.write(request.body);\n    }\n    httpRequest.end();\n  });\n};\n\nOAuth.prototype.buildRequest = function(method, path, params, body) {\n  if (path.indexOf(\"/\") != 0) {\n    path = \"/\" + path;\n  }\n  if (params && Object.keys(params).length > 0) {\n    path += \"?\" + OAuth.buildParameterString(params);\n  }\n\n  var request = {\n    host:   this.host,\n    path: \tpath,\n    method: method.toUpperCase()\n  };\n\n  var oauth_params = this.oauth_params || {};\n  oauth_params.oauth_consumer_key = this.consumer_key;\n  if(this.auth_token){\n    oauth_params[\"oauth_token\"] = this.auth_token;\n  }\n\n  request = OAuth.signRequest(request, oauth_params, this.consumer_secret,  this.auth_token_secret);\n\n  if (body && Object.keys(body).length > 0) {\n    request.body = OAuth.buildParameterString(body);\n  }\n  return request;\n}\n\nOAuth.prototype.get = function(path, params) {\n  return this.send(\"GET\", path, params);\n}\n\nOAuth.prototype.post = function(path, params, body) {\n  return this.send(\"POST\", path, params, body);\n}\n\n/*\n\tProper string %escape encoding\n*/\nOAuth.encode = function(str) {\n  //       discuss at: http://phpjs.org/functions/rawurlencode/\n  //      original by: Brett Zamir (http://brett-zamir.me)\n  //         input by: travc\n  //         input by: Brett Zamir (http://brett-zamir.me)\n  //         input by: Michael Grier\n  //         input by: Ratheous\n  //      bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)\n  //      bugfixed by: Brett Zamir (http://brett-zamir.me)\n  //      bugfixed by: Joris\n  // reimplemented by: Brett Zamir (http://brett-zamir.me)\n  // reimplemented by: Brett Zamir (http://brett-zamir.me)\n  //             note: This reflects PHP 5.3/6.0+ behavior\n  //             note: Please be aware that this function expects to encode into UTF-8 encoded strings, as found on\n  //             note: pages served as UTF-8\n  //        example 1: rawurlencode('Kevin van Zonneveld!');\n  //        returns 1: 'Kevin%20van%20Zonneveld%21'\n  //        example 2: rawurlencode('http://kevin.vanzonneveld.net/');\n  //        returns 2: 'http%3A%2F%2Fkevin.vanzonneveld.net%2F'\n  //        example 3: rawurlencode('http://www.google.nl/search?q=php.js&ie=utf-8&oe=utf-8&aq=t&rls=com.ubuntu:en-US:unofficial&client=firefox-a');\n  //        returns 3: 'http%3A%2F%2Fwww.google.nl%2Fsearch%3Fq%3Dphp.js%26ie%3Dutf-8%26oe%3Dutf-8%26aq%3Dt%26rls%3Dcom.ubuntu%3Aen-US%3Aunofficial%26client%3Dfirefox-a'\n\n  str = (str + '')\n    .toString();\n\n  // Tilde should be allowed unescaped in future versions of PHP (as reflected below), but if you want to reflect current\n  // PHP behavior, you would need to add \".replace(/~/g, '%7E');\" to the following.\n  return encodeURIComponent(str)\n    .replace(/!/g, '%21')\n    .replace(/'/g, '%27')\n    .replace(/\\(/g, '%28')\n    .replace(/\\)/g, '%29')\n    .replace(/\\*/g, '%2A');\n}\n\nOAuth.signatureMethod = \"HMAC-SHA1\";\nOAuth.version = \"1.0\";\n\n/*\n\tGenerate a nonce\n*/\nOAuth.nonce = function(){\n  var text = \"\";\n  var possible = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\";\n\n  for(var i = 0; i < 30; i++)\n    text += possible.charAt(Math.floor(Math.random() * possible.length));\n\n  return text;\n}\n\nOAuth.buildParameterString = function(obj){\n  // Sort keys and encode values\n  if (obj) {\n    var keys = Object.keys(obj).sort();\n\n    // Map key=value, join them by &\n    return keys.map(function(key){\n      return key + \"=\" + OAuth.encode(obj[key]);\n    }).join(\"&\");\n  }\n\n  return \"\";\n}\n\n/*\n\tBuild the signature string from the object\n*/\n\nOAuth.buildSignatureString = function(method, url, parameters){\n  return [method.toUpperCase(), OAuth.encode(url), OAuth.encode(parameters)].join(\"&\");\n}\n\n/*\n\tRetuns encoded HMAC-SHA1 from key and text\n*/\nOAuth.signature = function(text, key){\n  crypto = require(\"crypto\");\n  return OAuth.encode(crypto.createHmac('sha1', key).update(text).digest('base64'));\n}\n\nOAuth.signRequest = function(request, oauth_parameters, consumer_secret, auth_token_secret){\n  oauth_parameters = oauth_parameters || {};\n\n  // Set default values\n  if (!oauth_parameters.oauth_nonce) {\n    oauth_parameters.oauth_nonce = OAuth.nonce();\n  }\n  if (!oauth_parameters.oauth_timestamp) {\n    oauth_parameters.oauth_timestamp = Math.floor(new Date().getTime() / 1000);\n  }\n  if (!oauth_parameters.oauth_signature_method) {\n    oauth_parameters.oauth_signature_method = OAuth.signatureMethod;\n  }\n  if (!oauth_parameters.oauth_version) {\n    oauth_parameters.oauth_version = OAuth.version;\n  }\n\n  if(!auth_token_secret){\n    auth_token_secret = \"\";\n  }\n  // Force GET method if unset\n  if (!request.method) {\n    request.method = \"GET\"\n  }\n\n  // Collect  all the parameters in one signatureParameters object\n  var signatureParams = {};\n  var parametersToMerge = [request.params, request.body, oauth_parameters];\n  for(var i in parametersToMerge) {\n    var parameters = parametersToMerge[i];\n    for(var k in parameters) {\n      signatureParams[k] = parameters[k];\n    }\n  }\n\n  // Create a string based on the parameters\n  var parameterString = OAuth.buildParameterString(signatureParams);\n\n  // Build the signature string\n  var url = \"https://\" + request.host + \"\" + request.path;\n\n  var signatureString = OAuth.buildSignatureString(request.method, url, parameterString);\n  // Hash the signature string\n  var signatureKey = [OAuth.encode(consumer_secret), OAuth.encode(auth_token_secret)].join(\"&\");\n\n  var signature = OAuth.signature(signatureString, signatureKey);\n\n  // Set the signature in the params\n  oauth_parameters.oauth_signature = signature;\n  if(!request.headers){\n    request.headers = {};\n  }\n\n  // Set the authorization header\n  var authHeader = Object.keys(oauth_parameters).sort().map(function(key){\n    var value = oauth_parameters[key];\n    return key + '=\"' + value + '\"';\n  }).join(\", \")\n\n  request.headers.Authorization = 'OAuth ' + authHeader;\n\n  // Set the content type header\n  request.headers[\"Content-Type\"] = \"application/x-www-form-urlencoded\";\n  return request;\n\n}\n\nmodule.exports = OAuth;\n"]} \ No newline at end of file diff --git a/lib/Adapters/Auth/facebook.js b/lib/Adapters/Auth/facebook.js index 2e422926f8..825e6fe932 100644 --- a/lib/Adapters/Auth/facebook.js +++ b/lib/Adapters/Auth/facebook.js @@ -31,7 +31,7 @@ function validateAppId(appIds, authData) { // A promisey wrapper for FB graph requests. function graphRequest(path) { return new Promise(function (resolve, reject) { - https.get('https://graph.facebook.com/v2.5/' + path, function (res) { + https.get('https://graph.facebook.com/' + path, function (res) { var data = ''; res.on('data', function (chunk) { data += chunk; @@ -53,4 +53,5 @@ function graphRequest(path) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/facebookaccountkit.js b/lib/Adapters/Auth/facebookaccountkit.js index 1e975a08c5..2272362589 100644 --- a/lib/Adapters/Auth/facebookaccountkit.js +++ b/lib/Adapters/Auth/facebookaccountkit.js @@ -65,4 +65,5 @@ function validateAuthData(authData, options) { module.exports = { validateAppId, validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/github.js b/lib/Adapters/Auth/github.js index e727313fc7..ecfd8ceef9 100644 --- a/lib/Adapters/Auth/github.js +++ b/lib/Adapters/Auth/github.js @@ -51,4 +51,5 @@ function request(path, access_token) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/google.js b/lib/Adapters/Auth/google.js index 898eeeffdb..32ace595e5 100644 --- a/lib/Adapters/Auth/google.js +++ b/lib/Adapters/Auth/google.js @@ -67,4 +67,5 @@ function request(path) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/index.js b/lib/Adapters/Auth/index.js index 59b1392463..1935d38a9f 100755 --- a/lib/Adapters/Auth/index.js +++ b/lib/Adapters/Auth/index.js @@ -119,4 +119,5 @@ module.exports = function (authOptions = {}, enableAnonymousUsers = true) { }); }; -module.exports.loadAuthAdapter = loadAuthAdapter; \ No newline at end of file +module.exports.loadAuthAdapter = loadAuthAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Adapters/Auth/index.js"],"names":["facebook","require","facebookaccountkit","instagram","linkedin","meetup","google","github","twitter","spotify","digits","janrainengage","janraincapture","vkontakte","qq","wechat","weibo","anonymous","validateAuthData","Promise","resolve","validateAppId","providers","authDataValidator","adapter","appIds","options","authData","then","loadAuthAdapter","provider","authOptions","defaultAdapter","Object","assign","providerOptions","undefined","optionalAdapter","forEach","key","module","exports","enableAnonymousUsers","_enableAnonymousUsers","setEnableAnonymousUsers","enable","getValidatorForProvider","freeze"],"mappings":"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","file":"index.js","sourcesContent":["import loadAdapter from '../AdapterLoader';\n\nconst facebook = require('./facebook');\nconst facebookaccountkit = require('./facebookaccountkit');\nconst instagram = require(\"./instagram\");\nconst linkedin = require(\"./linkedin\");\nconst meetup = require(\"./meetup\");\nconst google = require(\"./google\");\nconst github = require(\"./github\");\nconst twitter = require(\"./twitter\");\nconst spotify = require(\"./spotify\");\nconst digits = require(\"./twitter\"); // digits tokens are validated by twitter\nconst janrainengage = require(\"./janrainengage\");\nconst janraincapture = require(\"./janraincapture\");\nconst vkontakte = require(\"./vkontakte\");\nconst qq = require(\"./qq\");\nconst wechat = require(\"./wechat\");\nconst weibo = require(\"./weibo\");\n\nconst anonymous = {\n  validateAuthData: () => {\n    return Promise.resolve();\n  },\n  validateAppId: () => {\n    return Promise.resolve();\n  }\n}\n\nconst providers = {\n  facebook,\n  facebookaccountkit,\n  instagram,\n  linkedin,\n  meetup,\n  google,\n  github,\n  twitter,\n  spotify,\n  anonymous,\n  digits,\n  janrainengage,\n  janraincapture,\n  vkontakte,\n  qq,\n  wechat,\n  weibo\n}\nfunction authDataValidator(adapter, appIds, options) {\n  return function(authData) {\n    return adapter.validateAuthData(authData, options).then(() => {\n      if (appIds) {\n        return adapter.validateAppId(appIds, authData, options);\n      }\n      return Promise.resolve();\n    });\n  }\n}\n\nfunction loadAuthAdapter(provider, authOptions) {\n  const defaultAdapter = providers[provider];\n  const adapter = Object.assign({}, defaultAdapter);\n  const providerOptions = authOptions[provider];\n\n  if (!defaultAdapter && !providerOptions) {\n    return;\n  }\n\n  const appIds = providerOptions ? providerOptions.appIds : undefined;\n\n  // Try the configuration methods\n  if (providerOptions) {\n    const optionalAdapter = loadAdapter(providerOptions, undefined, providerOptions);\n    if (optionalAdapter) {\n      ['validateAuthData', 'validateAppId'].forEach((key) => {\n        if (optionalAdapter[key]) {\n          adapter[key] = optionalAdapter[key];\n        }\n      });\n    }\n  }\n\n  if (!adapter.validateAuthData || !adapter.validateAppId) {\n    return;\n  }\n\n  return {adapter, appIds, providerOptions};\n}\n\nmodule.exports = function(authOptions = {}, enableAnonymousUsers = true) {\n  let _enableAnonymousUsers = enableAnonymousUsers;\n  const setEnableAnonymousUsers = function(enable) {\n    _enableAnonymousUsers = enable;\n  }\n  // To handle the test cases on configuration\n  const getValidatorForProvider = function(provider) {\n\n    if (provider === 'anonymous' && !_enableAnonymousUsers) {\n      return;\n    }\n\n    const {\n      adapter,\n      appIds,\n      providerOptions\n    } = loadAuthAdapter(provider, authOptions);\n\n    return authDataValidator(adapter, appIds, providerOptions);\n  }\n\n  return Object.freeze({\n    getValidatorForProvider,\n    setEnableAnonymousUsers\n  })\n}\n\nmodule.exports.loadAuthAdapter = loadAuthAdapter;\n"]} \ No newline at end of file diff --git a/lib/Adapters/Auth/instagram.js b/lib/Adapters/Auth/instagram.js index 090bc168d9..266519da97 100644 --- a/lib/Adapters/Auth/instagram.js +++ b/lib/Adapters/Auth/instagram.js @@ -40,4 +40,5 @@ function request(path) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/janraincapture.js b/lib/Adapters/Auth/janraincapture.js index bfab1a995c..5d897af342 100644 --- a/lib/Adapters/Auth/janraincapture.js +++ b/lib/Adapters/Auth/janraincapture.js @@ -52,4 +52,5 @@ function request(host, access_token) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/janrainengage.js b/lib/Adapters/Auth/janrainengage.js index c3936dfd63..8582e83699 100644 --- a/lib/Adapters/Auth/janrainengage.js +++ b/lib/Adapters/Auth/janrainengage.js @@ -70,4 +70,5 @@ function request(api_key, auth_token) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/linkedin.js b/lib/Adapters/Auth/linkedin.js index 702de7081b..943a6a659e 100644 --- a/lib/Adapters/Auth/linkedin.js +++ b/lib/Adapters/Auth/linkedin.js @@ -57,4 +57,5 @@ function request(path, access_token, is_mobile_sdk) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/meetup.js b/lib/Adapters/Auth/meetup.js index 7a996510b5..33fd7f34e6 100644 --- a/lib/Adapters/Auth/meetup.js +++ b/lib/Adapters/Auth/meetup.js @@ -50,4 +50,5 @@ function request(path, access_token) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/qq.js b/lib/Adapters/Auth/qq.js index aa82ca6b62..a5de7424aa 100644 --- a/lib/Adapters/Auth/qq.js +++ b/lib/Adapters/Auth/qq.js @@ -50,4 +50,5 @@ function graphRequest(path) { module.exports = { validateAppId, validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BdXRoL3FxLmpzIl0sIm5hbWVzIjpbImh0dHBzIiwicmVxdWlyZSIsIlBhcnNlIiwidmFsaWRhdGVBdXRoRGF0YSIsImF1dGhEYXRhIiwiZ3JhcGhSZXF1ZXN0IiwiYWNjZXNzX3Rva2VuIiwidGhlbiIsImRhdGEiLCJvcGVuaWQiLCJpZCIsIkVycm9yIiwiT0JKRUNUX05PVF9GT1VORCIsInZhbGlkYXRlQXBwSWQiLCJQcm9taXNlIiwicmVzb2x2ZSIsInBhdGgiLCJyZWplY3QiLCJnZXQiLCJyZXMiLCJvbiIsImNodW5rIiwic3RhclBvcyIsImluZGV4T2YiLCJlbmRQb3MiLCJzdWJzdHJpbmciLCJKU09OIiwicGFyc2UiLCJlIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6Ijs7QUFBQTtBQUNBLElBQUlBLFFBQVFDLFFBQVEsT0FBUixDQUFaO0FBQ0EsSUFBSUMsUUFBUUQsUUFBUSxZQUFSLEVBQXNCQyxLQUFsQzs7QUFFQTtBQUNBLFNBQVNDLGdCQUFULENBQTBCQyxRQUExQixFQUFvQztBQUNsQyxTQUFPQyxhQUFhLHFCQUFxQkQsU0FBU0UsWUFBM0MsRUFBeURDLElBQXpELENBQThELFVBQVVDLElBQVYsRUFBZ0I7QUFDbkYsUUFBSUEsUUFBUUEsS0FBS0MsTUFBTCxJQUFlTCxTQUFTTSxFQUFwQyxFQUF3QztBQUN0QztBQUNEO0FBQ0QsVUFBTSxJQUFJUixNQUFNUyxLQUFWLENBQWdCVCxNQUFNUyxLQUFOLENBQVlDLGdCQUE1QixFQUE4QyxtQ0FBOUMsQ0FBTjtBQUNELEdBTE0sQ0FBUDtBQU1EOztBQUVEO0FBQ0EsU0FBU0MsYUFBVCxHQUF5QjtBQUN2QixTQUFPQyxRQUFRQyxPQUFSLEVBQVA7QUFDRDs7QUFFRDtBQUNBLFNBQVNWLFlBQVQsQ0FBc0JXLElBQXRCLEVBQTRCO0FBQzFCLFNBQU8sSUFBSUYsT0FBSixDQUFZLFVBQVVDLE9BQVYsRUFBbUJFLE1BQW5CLEVBQTJCO0FBQzVDakIsVUFBTWtCLEdBQU4sQ0FBVSxtQ0FBbUNGLElBQTdDLEVBQW1ELFVBQVVHLEdBQVYsRUFBZTtBQUNoRSxVQUFJWCxPQUFPLEVBQVg7QUFDQVcsVUFBSUMsRUFBSixDQUFPLE1BQVAsRUFBZSxVQUFVQyxLQUFWLEVBQWlCO0FBQzlCYixnQkFBUWEsS0FBUjtBQUNELE9BRkQ7QUFHQUYsVUFBSUMsRUFBSixDQUFPLEtBQVAsRUFBYyxZQUFZO0FBQ3hCLFlBQUlFLFVBQVVkLEtBQUtlLE9BQUwsQ0FBYSxHQUFiLENBQWQ7QUFDQSxZQUFJQyxTQUFTaEIsS0FBS2UsT0FBTCxDQUFhLEdBQWIsQ0FBYjtBQUNBLFlBQUdELFdBQVcsQ0FBQyxDQUFaLElBQWlCRSxVQUFVLENBQUMsQ0FBL0IsRUFBaUM7QUFDL0IsZ0JBQU0sSUFBSXRCLE1BQU1TLEtBQVYsQ0FBZ0JULE1BQU1TLEtBQU4sQ0FBWUMsZ0JBQTVCLEVBQThDLG1DQUE5QyxDQUFOO0FBQ0Q7QUFDREosZUFBT0EsS0FBS2lCLFNBQUwsQ0FBZUgsVUFBVSxDQUF6QixFQUEyQkUsU0FBUyxDQUFwQyxDQUFQO0FBQ0EsWUFBSTtBQUNGaEIsaUJBQU9rQixLQUFLQyxLQUFMLENBQVduQixJQUFYLENBQVA7QUFDRCxTQUZELENBRUUsT0FBTW9CLENBQU4sRUFBUztBQUNULGlCQUFPWCxPQUFPVyxDQUFQLENBQVA7QUFDRDtBQUNEYixnQkFBUVAsSUFBUjtBQUNELE9BYkQ7QUFjRCxLQW5CRCxFQW1CR1ksRUFuQkgsQ0FtQk0sT0FuQk4sRUFtQmUsWUFBWTtBQUN6QkgsYUFBTywrQ0FBUDtBQUNELEtBckJEO0FBc0JELEdBdkJNLENBQVA7QUF3QkQ7O0FBRURZLE9BQU9DLE9BQVAsR0FBaUI7QUFDZmpCLGVBRGU7QUFFZlY7QUFGZSxDQUFqQiIsImZpbGUiOiJxcS5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEhlbHBlciBmdW5jdGlvbnMgZm9yIGFjY2Vzc2luZyB0aGUgcXEgR3JhcGggQVBJLlxudmFyIGh0dHBzID0gcmVxdWlyZSgnaHR0cHMnKTtcbnZhciBQYXJzZSA9IHJlcXVpcmUoJ3BhcnNlL25vZGUnKS5QYXJzZTtcblxuLy8gUmV0dXJucyBhIHByb21pc2UgdGhhdCBmdWxmaWxscyBpZmYgdGhpcyB1c2VyIGlkIGlzIHZhbGlkLlxuZnVuY3Rpb24gdmFsaWRhdGVBdXRoRGF0YShhdXRoRGF0YSkge1xuICByZXR1cm4gZ3JhcGhSZXF1ZXN0KCdtZT9hY2Nlc3NfdG9rZW49JyArIGF1dGhEYXRhLmFjY2Vzc190b2tlbikudGhlbihmdW5jdGlvbiAoZGF0YSkge1xuICAgIGlmIChkYXRhICYmIGRhdGEub3BlbmlkID09IGF1dGhEYXRhLmlkKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIHRocm93IG5ldyBQYXJzZS5FcnJvcihQYXJzZS5FcnJvci5PQkpFQ1RfTk9UX0ZPVU5ELCAncXEgYXV0aCBpcyBpbnZhbGlkIGZvciB0aGlzIHVzZXIuJyk7XG4gIH0pO1xufVxuXG4vLyBSZXR1cm5zIGEgcHJvbWlzZSB0aGF0IGZ1bGZpbGxzIGlmIHRoaXMgYXBwIGlkIGlzIHZhbGlkLlxuZnVuY3Rpb24gdmFsaWRhdGVBcHBJZCgpIHtcbiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xufVxuXG4vLyBBIHByb21pc2V5IHdyYXBwZXIgZm9yIHFxIGdyYXBoIHJlcXVlc3RzLlxuZnVuY3Rpb24gZ3JhcGhSZXF1ZXN0KHBhdGgpIHtcbiAgcmV0dXJuIG5ldyBQcm9taXNlKGZ1bmN0aW9uIChyZXNvbHZlLCByZWplY3QpIHtcbiAgICBodHRwcy5nZXQoJ2h0dHBzOi8vZ3JhcGgucXEuY29tL29hdXRoMi4wLycgKyBwYXRoLCBmdW5jdGlvbiAocmVzKSB7XG4gICAgICB2YXIgZGF0YSA9ICcnO1xuICAgICAgcmVzLm9uKCdkYXRhJywgZnVuY3Rpb24gKGNodW5rKSB7XG4gICAgICAgIGRhdGEgKz0gY2h1bms7XG4gICAgICB9KTtcbiAgICAgIHJlcy5vbignZW5kJywgZnVuY3Rpb24gKCkge1xuICAgICAgICB2YXIgc3RhclBvcyA9IGRhdGEuaW5kZXhPZihcIihcIik7XG4gICAgICAgIHZhciBlbmRQb3MgPSBkYXRhLmluZGV4T2YoXCIpXCIpO1xuICAgICAgICBpZihzdGFyUG9zID09IC0xIHx8IGVuZFBvcyA9PSAtMSl7XG4gICAgICAgICAgdGhyb3cgbmV3IFBhcnNlLkVycm9yKFBhcnNlLkVycm9yLk9CSkVDVF9OT1RfRk9VTkQsICdxcSBhdXRoIGlzIGludmFsaWQgZm9yIHRoaXMgdXNlci4nKTtcbiAgICAgICAgfVxuICAgICAgICBkYXRhID0gZGF0YS5zdWJzdHJpbmcoc3RhclBvcyArIDEsZW5kUG9zIC0gMSk7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgZGF0YSA9IEpTT04ucGFyc2UoZGF0YSk7XG4gICAgICAgIH0gY2F0Y2goZSkge1xuICAgICAgICAgIHJldHVybiByZWplY3QoZSk7XG4gICAgICAgIH1cbiAgICAgICAgcmVzb2x2ZShkYXRhKTtcbiAgICAgIH0pO1xuICAgIH0pLm9uKCdlcnJvcicsIGZ1bmN0aW9uICgpIHtcbiAgICAgIHJlamVjdCgnRmFpbGVkIHRvIHZhbGlkYXRlIHRoaXMgYWNjZXNzIHRva2VuIHdpdGggcXEuJyk7XG4gICAgfSk7XG4gIH0pO1xufVxuXG5tb2R1bGUuZXhwb3J0cyA9IHtcbiAgdmFsaWRhdGVBcHBJZCxcbiAgdmFsaWRhdGVBdXRoRGF0YVxufTtcbiJdfQ== \ No newline at end of file diff --git a/lib/Adapters/Auth/spotify.js b/lib/Adapters/Auth/spotify.js index f1d8f6da21..b102c58b84 100644 --- a/lib/Adapters/Auth/spotify.js +++ b/lib/Adapters/Auth/spotify.js @@ -59,4 +59,5 @@ function request(path, access_token) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/twitter.js b/lib/Adapters/Auth/twitter.js index 4f4560fedc..456fd342e1 100644 --- a/lib/Adapters/Auth/twitter.js +++ b/lib/Adapters/Auth/twitter.js @@ -53,4 +53,5 @@ module.exports = { validateAppId, validateAuthData, handleMultipleConfigurations -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/vkontakte.js b/lib/Adapters/Auth/vkontakte.js index 195a33f93b..9ef0fa1d5e 100644 --- a/lib/Adapters/Auth/vkontakte.js +++ b/lib/Adapters/Auth/vkontakte.js @@ -10,7 +10,7 @@ var logger = require('../../logger').default; function validateAuthData(authData, params) { return vkOAuth2Request(params).then(function (response) { if (response && response.access_token) { - return request("api.vk.com", "method/secure.checkToken?token=" + authData.access_token + "&client_secret=" + params.appSecret + "&access_token=" + response.access_token).then(function (response) { + return request("api.vk.com", "method/secure.checkToken?token=" + authData.access_token + "&client_secret=" + params.appSecret + "&access_token=" + response.access_token + "&v=5.59").then(function (response) { if (response && response.response && response.response.user_id == authData.id) { return; } @@ -64,4 +64,5 @@ function request(host, path) { module.exports = { validateAppId: validateAppId, validateAuthData: validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/wechat.js b/lib/Adapters/Auth/wechat.js index 1f0aebaa50..62062b210b 100644 --- a/lib/Adapters/Auth/wechat.js +++ b/lib/Adapters/Auth/wechat.js @@ -44,4 +44,5 @@ function graphRequest(path) { module.exports = { validateAppId, validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Auth/weibo.js b/lib/Adapters/Auth/weibo.js index b6a0d0f46d..db29576bf0 100644 --- a/lib/Adapters/Auth/weibo.js +++ b/lib/Adapters/Auth/weibo.js @@ -63,4 +63,5 @@ function graphRequest(access_token) { module.exports = { validateAppId, validateAuthData -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Cache/CacheAdapter.js b/lib/Adapters/Cache/CacheAdapter.js index bbb17ef749..402a231ebb 100644 --- a/lib/Adapters/Cache/CacheAdapter.js +++ b/lib/Adapters/Cache/CacheAdapter.js @@ -31,4 +31,5 @@ class CacheAdapter { */ clear() {} } -exports.CacheAdapter = CacheAdapter; \ No newline at end of file +exports.CacheAdapter = CacheAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9DYWNoZUFkYXB0ZXIuanMiXSwibmFtZXMiOlsiQ2FjaGVBZGFwdGVyIiwiZ2V0Iiwia2V5IiwicHV0IiwidmFsdWUiLCJ0dGwiLCJkZWwiLCJjbGVhciJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQUNPLE1BQU1BLFlBQU4sQ0FBbUI7QUFDeEI7Ozs7O0FBS0FDLE1BQUlDLEdBQUosRUFBUyxDQUFFOztBQUVYOzs7Ozs7QUFNQUMsTUFBSUQsR0FBSixFQUFTRSxLQUFULEVBQWdCQyxHQUFoQixFQUFxQixDQUFFOztBQUV2Qjs7OztBQUlBQyxNQUFJSixHQUFKLEVBQVMsQ0FBRTs7QUFFWDs7O0FBR0FLLFVBQVEsQ0FBRTtBQXpCYztRQUFiUCxZLEdBQUFBLFkiLCJmaWxlIjoiQ2FjaGVBZGFwdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyplc2xpbnQgbm8tdW51c2VkLXZhcnM6IFwib2ZmXCIqL1xuZXhwb3J0IGNsYXNzIENhY2hlQWRhcHRlciB7XG4gIC8qKlxuICAgKiBHZXQgYSB2YWx1ZSBpbiB0aGUgY2FjaGVcbiAgICogQHBhcmFtIGtleSBDYWNoZSBrZXkgdG8gZ2V0XG4gICAqIEByZXR1cm4gUHJvbWlzZSB0aGF0IHdpbGwgZXZlbnR1YWxseSByZXNvbHZlIHRvIHRoZSB2YWx1ZSBpbiB0aGUgY2FjaGUuXG4gICAqL1xuICBnZXQoa2V5KSB7fVxuXG4gIC8qKlxuICAgKiBTZXQgYSB2YWx1ZSBpbiB0aGUgY2FjaGVcbiAgICogQHBhcmFtIGtleSBDYWNoZSBrZXkgdG8gc2V0XG4gICAqIEBwYXJhbSB2YWx1ZSBWYWx1ZSB0byBzZXQgdGhlIGtleVxuICAgKiBAcGFyYW0gdHRsIE9wdGlvbmFsIFRUTFxuICAgKi9cbiAgcHV0KGtleSwgdmFsdWUsIHR0bCkge31cblxuICAvKipcbiAgICogUmVtb3ZlIGEgdmFsdWUgZnJvbSB0aGUgY2FjaGUuXG4gICAqIEBwYXJhbSBrZXkgQ2FjaGUga2V5IHRvIHJlbW92ZVxuICAgKi9cbiAgZGVsKGtleSkge31cblxuICAvKipcbiAgICogRW1wdHkgYSBjYWNoZVxuICAgKi9cbiAgY2xlYXIoKSB7fVxufVxuIl19 \ No newline at end of file diff --git a/lib/Adapters/Cache/InMemoryCache.js b/lib/Adapters/Cache/InMemoryCache.js index c76bbc729d..3fef58804e 100644 --- a/lib/Adapters/Cache/InMemoryCache.js +++ b/lib/Adapters/Cache/InMemoryCache.js @@ -67,4 +67,5 @@ class InMemoryCache { } exports.InMemoryCache = InMemoryCache; -exports.default = InMemoryCache; \ No newline at end of file +exports.default = InMemoryCache; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Cache/InMemoryCacheAdapter.js b/lib/Adapters/Cache/InMemoryCacheAdapter.js index e3705c920c..5abd33a629 100644 --- a/lib/Adapters/Cache/InMemoryCacheAdapter.js +++ b/lib/Adapters/Cache/InMemoryCacheAdapter.js @@ -38,4 +38,5 @@ class InMemoryCacheAdapter { } exports.InMemoryCacheAdapter = InMemoryCacheAdapter; -exports.default = InMemoryCacheAdapter; \ No newline at end of file +exports.default = InMemoryCacheAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9Jbk1lbW9yeUNhY2hlQWRhcHRlci5qcyJdLCJuYW1lcyI6WyJJbk1lbW9yeUNhY2hlQWRhcHRlciIsImNvbnN0cnVjdG9yIiwiY3R4IiwiY2FjaGUiLCJMUlVDYWNoZSIsImdldCIsImtleSIsInJlY29yZCIsIlByb21pc2UiLCJyZXNvbHZlIiwicHV0IiwidmFsdWUiLCJ0dGwiLCJkZWwiLCJjbGVhciJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBOztBQUVPLE1BQU1BLG9CQUFOLENBQTJCOztBQUVoQ0MsY0FBWUMsR0FBWixFQUFpQjtBQUNmLFNBQUtDLEtBQUwsR0FBYSxJQUFJQyxrQkFBSixDQUFhRixHQUFiLENBQWI7QUFDRDs7QUFFREcsTUFBSUMsR0FBSixFQUFTO0FBQ1AsVUFBTUMsU0FBUyxLQUFLSixLQUFMLENBQVdFLEdBQVgsQ0FBZUMsR0FBZixDQUFmO0FBQ0EsUUFBSUMsV0FBVyxJQUFmLEVBQXFCO0FBQ25CLGFBQU9DLFFBQVFDLE9BQVIsQ0FBZ0IsSUFBaEIsQ0FBUDtBQUNEO0FBQ0QsV0FBT0QsUUFBUUMsT0FBUixDQUFnQkYsTUFBaEIsQ0FBUDtBQUNEOztBQUVERyxNQUFJSixHQUFKLEVBQVNLLEtBQVQsRUFBZ0JDLEdBQWhCLEVBQXFCO0FBQ25CLFNBQUtULEtBQUwsQ0FBV08sR0FBWCxDQUFlSixHQUFmLEVBQW9CSyxLQUFwQixFQUEyQkMsR0FBM0I7QUFDQSxXQUFPSixRQUFRQyxPQUFSLEVBQVA7QUFDRDs7QUFFREksTUFBSVAsR0FBSixFQUFTO0FBQ1AsU0FBS0gsS0FBTCxDQUFXVSxHQUFYLENBQWVQLEdBQWY7QUFDQSxXQUFPRSxRQUFRQyxPQUFSLEVBQVA7QUFDRDs7QUFFREssVUFBUTtBQUNOLFNBQUtYLEtBQUwsQ0FBV1csS0FBWDtBQUNBLFdBQU9OLFFBQVFDLE9BQVIsRUFBUDtBQUNEO0FBM0IrQjs7UUFBckJULG9CLEdBQUFBLG9CO2tCQThCRUEsb0IiLCJmaWxlIjoiSW5NZW1vcnlDYWNoZUFkYXB0ZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0xSVUNhY2hlfSBmcm9tICcuL0xSVUNhY2hlJztcblxuZXhwb3J0IGNsYXNzIEluTWVtb3J5Q2FjaGVBZGFwdGVyIHtcblxuICBjb25zdHJ1Y3RvcihjdHgpIHtcbiAgICB0aGlzLmNhY2hlID0gbmV3IExSVUNhY2hlKGN0eClcbiAgfVxuXG4gIGdldChrZXkpIHtcbiAgICBjb25zdCByZWNvcmQgPSB0aGlzLmNhY2hlLmdldChrZXkpO1xuICAgIGlmIChyZWNvcmQgPT09IG51bGwpIHtcbiAgICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUobnVsbCk7XG4gICAgfVxuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUocmVjb3JkKTtcbiAgfVxuXG4gIHB1dChrZXksIHZhbHVlLCB0dGwpIHtcbiAgICB0aGlzLmNhY2hlLnB1dChrZXksIHZhbHVlLCB0dGwpO1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoKTtcbiAgfVxuXG4gIGRlbChrZXkpIHtcbiAgICB0aGlzLmNhY2hlLmRlbChrZXkpO1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoKTtcbiAgfVxuXG4gIGNsZWFyKCkge1xuICAgIHRoaXMuY2FjaGUuY2xlYXIoKTtcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKCk7XG4gIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgSW5NZW1vcnlDYWNoZUFkYXB0ZXI7XG4iXX0= \ No newline at end of file diff --git a/lib/Adapters/Cache/LRUCache.js b/lib/Adapters/Cache/LRUCache.js index a4476aa154..e3b0acc5db 100644 --- a/lib/Adapters/Cache/LRUCache.js +++ b/lib/Adapters/Cache/LRUCache.js @@ -45,4 +45,5 @@ class LRUCache { } exports.LRUCache = LRUCache; -exports.default = LRUCache; \ No newline at end of file +exports.default = LRUCache; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9MUlVDYWNoZS5qcyJdLCJuYW1lcyI6WyJMUlVDYWNoZSIsImNvbnN0cnVjdG9yIiwidHRsIiwiZGVmYXVsdHMiLCJjYWNoZVRUTCIsIm1heFNpemUiLCJjYWNoZU1heFNpemUiLCJjYWNoZSIsIkxSVSIsIm1heCIsIm1heEFnZSIsImdldCIsImtleSIsInB1dCIsInZhbHVlIiwic2V0IiwiZGVsIiwiY2xlYXIiLCJyZXNldCJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBOzs7O0FBQ0E7Ozs7OztBQUVPLE1BQU1BLFFBQU4sQ0FBZTtBQUNwQkMsY0FBWTtBQUNWQyxVQUFNQyxtQkFBU0MsUUFETDtBQUVWQyxjQUFVRixtQkFBU0c7QUFGVCxHQUFaLEVBR0c7QUFDRCxTQUFLQyxLQUFMLEdBQWEsSUFBSUMsa0JBQUosQ0FBUTtBQUNuQkMsV0FBS0osT0FEYztBQUVuQkssY0FBUVI7QUFGVyxLQUFSLENBQWI7QUFJRDs7QUFFRFMsTUFBSUMsR0FBSixFQUFTO0FBQ1AsV0FBTyxLQUFLTCxLQUFMLENBQVdJLEdBQVgsQ0FBZUMsR0FBZixLQUF1QixJQUE5QjtBQUNEOztBQUVEQyxNQUFJRCxHQUFKLEVBQVNFLEtBQVQsRUFBZ0JaLE1BQU0sS0FBS0EsR0FBM0IsRUFBZ0M7QUFDOUIsU0FBS0ssS0FBTCxDQUFXUSxHQUFYLENBQWVILEdBQWYsRUFBb0JFLEtBQXBCLEVBQTJCWixHQUEzQjtBQUNEOztBQUVEYyxNQUFJSixHQUFKLEVBQVM7QUFDUCxTQUFLTCxLQUFMLENBQVdTLEdBQVgsQ0FBZUosR0FBZjtBQUNEOztBQUVESyxVQUFRO0FBQ04sU0FBS1YsS0FBTCxDQUFXVyxLQUFYO0FBQ0Q7O0FBekJtQjs7UUFBVGxCLFEsR0FBQUEsUTtrQkE2QkVBLFEiLCJmaWxlIjoiTFJVQ2FjaGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTFJVIGZyb20gJ2xydS1jYWNoZSc7XG5pbXBvcnQgZGVmYXVsdHMgIGZyb20gJy4uLy4uL2RlZmF1bHRzJztcblxuZXhwb3J0IGNsYXNzIExSVUNhY2hlIHtcbiAgY29uc3RydWN0b3Ioe1xuICAgIHR0bCA9IGRlZmF1bHRzLmNhY2hlVFRMLFxuICAgIG1heFNpemUgPSBkZWZhdWx0cy5jYWNoZU1heFNpemUsXG4gIH0pIHtcbiAgICB0aGlzLmNhY2hlID0gbmV3IExSVSh7XG4gICAgICBtYXg6IG1heFNpemUsXG4gICAgICBtYXhBZ2U6IHR0bFxuICAgIH0pO1xuICB9XG5cbiAgZ2V0KGtleSkge1xuICAgIHJldHVybiB0aGlzLmNhY2hlLmdldChrZXkpIHx8IG51bGw7XG4gIH1cblxuICBwdXQoa2V5LCB2YWx1ZSwgdHRsID0gdGhpcy50dGwpIHtcbiAgICB0aGlzLmNhY2hlLnNldChrZXksIHZhbHVlLCB0dGwpO1xuICB9XG5cbiAgZGVsKGtleSkge1xuICAgIHRoaXMuY2FjaGUuZGVsKGtleSk7XG4gIH1cblxuICBjbGVhcigpIHtcbiAgICB0aGlzLmNhY2hlLnJlc2V0KCk7XG4gIH1cblxufVxuXG5leHBvcnQgZGVmYXVsdCBMUlVDYWNoZTtcbiJdfQ== \ No newline at end of file diff --git a/lib/Adapters/Cache/NullCacheAdapter.js b/lib/Adapters/Cache/NullCacheAdapter.js index 55d536878c..cdb02b4e8a 100644 --- a/lib/Adapters/Cache/NullCacheAdapter.js +++ b/lib/Adapters/Cache/NullCacheAdapter.js @@ -27,4 +27,5 @@ class NullCacheAdapter { } exports.NullCacheAdapter = NullCacheAdapter; -exports.default = NullCacheAdapter; \ No newline at end of file +exports.default = NullCacheAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9OdWxsQ2FjaGVBZGFwdGVyLmpzIl0sIm5hbWVzIjpbIk51bGxDYWNoZUFkYXB0ZXIiLCJjb25zdHJ1Y3RvciIsImdldCIsIlByb21pc2UiLCJyZXNvbHZlIiwicHV0IiwiZGVsIiwiY2xlYXIiXSwibWFwcGluZ3MiOiI7Ozs7O0FBQU8sTUFBTUEsZ0JBQU4sQ0FBdUI7O0FBRTVCQyxnQkFBYyxDQUFFOztBQUVoQkMsUUFBTTtBQUNKLFdBQU8sSUFBSUMsT0FBSixDQUFhQyxPQUFELElBQWE7QUFDOUIsYUFBT0EsUUFBUSxJQUFSLENBQVA7QUFDRCxLQUZNLENBQVA7QUFHRDs7QUFFREMsUUFBTTtBQUNKLFdBQU9GLFFBQVFDLE9BQVIsRUFBUDtBQUNEOztBQUVERSxRQUFNO0FBQ0osV0FBT0gsUUFBUUMsT0FBUixFQUFQO0FBQ0Q7O0FBRURHLFVBQVE7QUFDTixXQUFPSixRQUFRQyxPQUFSLEVBQVA7QUFDRDtBQXBCMkI7O1FBQWpCSixnQixHQUFBQSxnQjtrQkF1QkVBLGdCIiwiZmlsZSI6Ik51bGxDYWNoZUFkYXB0ZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgTnVsbENhY2hlQWRhcHRlciB7XG5cbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIGdldCgpIHtcbiAgICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHtcbiAgICAgIHJldHVybiByZXNvbHZlKG51bGwpO1xuICAgIH0pXG4gIH1cblxuICBwdXQoKSB7XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xuICB9XG5cbiAgZGVsKCkge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoKTtcbiAgfVxuXG4gIGNsZWFyKCkge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoKTtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBOdWxsQ2FjaGVBZGFwdGVyO1xuIl19 \ No newline at end of file diff --git a/lib/Adapters/Cache/RedisCacheAdapter.js b/lib/Adapters/Cache/RedisCacheAdapter.js index 615a4c8250..028a069ec0 100644 --- a/lib/Adapters/Cache/RedisCacheAdapter.js +++ b/lib/Adapters/Cache/RedisCacheAdapter.js @@ -96,4 +96,5 @@ class RedisCacheAdapter { } exports.RedisCacheAdapter = RedisCacheAdapter; -exports.default = RedisCacheAdapter; \ No newline at end of file +exports.default = RedisCacheAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9SZWRpc0NhY2hlQWRhcHRlci5qcyJdLCJuYW1lcyI6WyJERUZBVUxUX1JFRElTX1RUTCIsImRlYnVnIiwibG9nZ2VyIiwiYXBwbHkiLCJhcmd1bWVudHMiLCJSZWRpc0NhY2hlQWRhcHRlciIsImNvbnN0cnVjdG9yIiwicmVkaXNDdHgiLCJ0dGwiLCJjbGllbnQiLCJyZWRpcyIsImNyZWF0ZUNsaWVudCIsInAiLCJQcm9taXNlIiwicmVzb2x2ZSIsImdldCIsImtleSIsInRoZW4iLCJlcnIiLCJyZXMiLCJKU09OIiwicGFyc2UiLCJwdXQiLCJ2YWx1ZSIsInN0cmluZ2lmeSIsImlzTmFOIiwiSW5maW5pdHkiLCJzZXQiLCJwc2V0ZXgiLCJkZWwiLCJjbGVhciIsImZsdXNoZGIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQTs7OztBQUNBOzs7Ozs7QUFFQSxNQUFNQSxvQkFBb0IsS0FBSyxJQUEvQixDLENBQXFDOztBQUVyQyxTQUFTQyxLQUFULEdBQWlCO0FBQ2ZDLG1CQUFPRCxLQUFQLENBQWFFLEtBQWIsQ0FBbUJELGdCQUFuQixFQUEyQixDQUFDLG1CQUFELEVBQXNCLEdBQUdFLFNBQXpCLENBQTNCO0FBQ0Q7O0FBRU0sTUFBTUMsaUJBQU4sQ0FBd0I7O0FBRTdCQyxjQUFZQyxRQUFaLEVBQXNCQyxNQUFNUixpQkFBNUIsRUFBK0M7QUFDN0MsU0FBS1MsTUFBTCxHQUFjQyxnQkFBTUMsWUFBTixDQUFtQkosUUFBbkIsQ0FBZDtBQUNBLFNBQUtLLENBQUwsR0FBU0MsUUFBUUMsT0FBUixFQUFUO0FBQ0EsU0FBS04sR0FBTCxHQUFXQSxHQUFYO0FBQ0Q7O0FBRURPLE1BQUlDLEdBQUosRUFBUztBQUNQZixVQUFNLEtBQU4sRUFBYWUsR0FBYjtBQUNBLFNBQUtKLENBQUwsR0FBUyxLQUFLQSxDQUFMLENBQU9LLElBQVAsQ0FBWSxNQUFNO0FBQ3pCLGFBQU8sSUFBSUosT0FBSixDQUFhQyxPQUFELElBQWE7QUFDOUIsYUFBS0wsTUFBTCxDQUFZTSxHQUFaLENBQWdCQyxHQUFoQixFQUFxQixVQUFTRSxHQUFULEVBQWNDLEdBQWQsRUFBbUI7QUFDdENsQixnQkFBTSxRQUFOLEVBQWdCZSxHQUFoQixFQUFxQkcsR0FBckI7QUFDQSxjQUFHLENBQUNBLEdBQUosRUFBUztBQUNQLG1CQUFPTCxRQUFRLElBQVIsQ0FBUDtBQUNEO0FBQ0RBLGtCQUFRTSxLQUFLQyxLQUFMLENBQVdGLEdBQVgsQ0FBUjtBQUNELFNBTkQ7QUFPRCxPQVJNLENBQVA7QUFTRCxLQVZRLENBQVQ7QUFXQSxXQUFPLEtBQUtQLENBQVo7QUFDRDs7QUFFRFUsTUFBSU4sR0FBSixFQUFTTyxLQUFULEVBQWdCZixNQUFNLEtBQUtBLEdBQTNCLEVBQWdDO0FBQzlCZSxZQUFRSCxLQUFLSSxTQUFMLENBQWVELEtBQWYsQ0FBUjtBQUNBdEIsVUFBTSxLQUFOLEVBQWFlLEdBQWIsRUFBa0JPLEtBQWxCLEVBQXlCZixHQUF6QjtBQUNBLFFBQUlBLFFBQVEsQ0FBWixFQUFlO0FBQ2IsYUFBTyxLQUFLSSxDQUFaLENBRGEsQ0FDRTtBQUNoQjtBQUNELFFBQUlKLE1BQU0sQ0FBTixJQUFXaUIsTUFBTWpCLEdBQU4sQ0FBZixFQUEyQjtBQUN6QkEsWUFBTVIsaUJBQU47QUFDRDtBQUNELFNBQUtZLENBQUwsR0FBUyxLQUFLQSxDQUFMLENBQU9LLElBQVAsQ0FBWSxNQUFNO0FBQ3pCLGFBQU8sSUFBSUosT0FBSixDQUFhQyxPQUFELElBQWE7QUFDOUIsWUFBSU4sUUFBUWtCLFFBQVosRUFBc0I7QUFDcEIsZUFBS2pCLE1BQUwsQ0FBWWtCLEdBQVosQ0FBZ0JYLEdBQWhCLEVBQXFCTyxLQUFyQixFQUE0QixZQUFXO0FBQ3JDVDtBQUNELFdBRkQ7QUFHRCxTQUpELE1BSU87QUFDTCxlQUFLTCxNQUFMLENBQVltQixNQUFaLENBQW1CWixHQUFuQixFQUF3QlIsR0FBeEIsRUFBNkJlLEtBQTdCLEVBQW9DLFlBQVc7QUFDN0NUO0FBQ0QsV0FGRDtBQUdEO0FBQ0YsT0FWTSxDQUFQO0FBV0QsS0FaUSxDQUFUO0FBYUEsV0FBTyxLQUFLRixDQUFaO0FBQ0Q7O0FBRURpQixNQUFJYixHQUFKLEVBQVM7QUFDUGYsVUFBTSxLQUFOLEVBQWFlLEdBQWI7QUFDQSxTQUFLSixDQUFMLEdBQVMsS0FBS0EsQ0FBTCxDQUFPSyxJQUFQLENBQVksTUFBTTtBQUN6QixhQUFPLElBQUlKLE9BQUosQ0FBYUMsT0FBRCxJQUFhO0FBQzlCLGFBQUtMLE1BQUwsQ0FBWW9CLEdBQVosQ0FBZ0JiLEdBQWhCLEVBQXFCLFlBQVc7QUFDOUJGO0FBQ0QsU0FGRDtBQUdELE9BSk0sQ0FBUDtBQUtELEtBTlEsQ0FBVDtBQU9BLFdBQU8sS0FBS0YsQ0FBWjtBQUNEOztBQUVEa0IsVUFBUTtBQUNON0IsVUFBTSxPQUFOO0FBQ0EsU0FBS1csQ0FBTCxHQUFTLEtBQUtBLENBQUwsQ0FBT0ssSUFBUCxDQUFZLE1BQU07QUFDekIsYUFBTyxJQUFJSixPQUFKLENBQWFDLE9BQUQsSUFBYTtBQUM5QixhQUFLTCxNQUFMLENBQVlzQixPQUFaLENBQW9CLFlBQVc7QUFDN0JqQjtBQUNELFNBRkQ7QUFHRCxPQUpNLENBQVA7QUFLRCxLQU5RLENBQVQ7QUFPQSxXQUFPLEtBQUtGLENBQVo7QUFDRDtBQXZFNEI7O1FBQWxCUCxpQixHQUFBQSxpQjtrQkEwRUVBLGlCIiwiZmlsZSI6IlJlZGlzQ2FjaGVBZGFwdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHJlZGlzIGZyb20gJ3JlZGlzJztcbmltcG9ydCBsb2dnZXIgZnJvbSAnLi4vLi4vbG9nZ2VyJztcblxuY29uc3QgREVGQVVMVF9SRURJU19UVEwgPSAzMCAqIDEwMDA7IC8vIDMwIHNlY29uZHMgaW4gbWlsbGlzZWNvbmRzXG5cbmZ1bmN0aW9uIGRlYnVnKCkge1xuICBsb2dnZXIuZGVidWcuYXBwbHkobG9nZ2VyLCBbJ1JlZGlzQ2FjaGVBZGFwdGVyJywgLi4uYXJndW1lbnRzXSk7XG59XG5cbmV4cG9ydCBjbGFzcyBSZWRpc0NhY2hlQWRhcHRlciB7XG5cbiAgY29uc3RydWN0b3IocmVkaXNDdHgsIHR0bCA9IERFRkFVTFRfUkVESVNfVFRMKSB7XG4gICAgdGhpcy5jbGllbnQgPSByZWRpcy5jcmVhdGVDbGllbnQocmVkaXNDdHgpO1xuICAgIHRoaXMucCA9IFByb21pc2UucmVzb2x2ZSgpO1xuICAgIHRoaXMudHRsID0gdHRsO1xuICB9XG5cbiAgZ2V0KGtleSkge1xuICAgIGRlYnVnKCdnZXQnLCBrZXkpO1xuICAgIHRoaXMucCA9IHRoaXMucC50aGVuKCgpID0+IHtcbiAgICAgIHJldHVybiBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4ge1xuICAgICAgICB0aGlzLmNsaWVudC5nZXQoa2V5LCBmdW5jdGlvbihlcnIsIHJlcykge1xuICAgICAgICAgIGRlYnVnKCctPiBnZXQnLCBrZXksIHJlcyk7XG4gICAgICAgICAgaWYoIXJlcykge1xuICAgICAgICAgICAgcmV0dXJuIHJlc29sdmUobnVsbCk7XG4gICAgICAgICAgfVxuICAgICAgICAgIHJlc29sdmUoSlNPTi5wYXJzZShyZXMpKTtcbiAgICAgICAgfSk7XG4gICAgICB9KTtcbiAgICB9KTtcbiAgICByZXR1cm4gdGhpcy5wO1xuICB9XG5cbiAgcHV0KGtleSwgdmFsdWUsIHR0bCA9IHRoaXMudHRsKSB7XG4gICAgdmFsdWUgPSBKU09OLnN0cmluZ2lmeSh2YWx1ZSk7XG4gICAgZGVidWcoJ3B1dCcsIGtleSwgdmFsdWUsIHR0bCk7XG4gICAgaWYgKHR0bCA9PT0gMCkge1xuICAgICAgcmV0dXJuIHRoaXMucDsgLy8gdHRsIG9mIHplcm8gaXMgYSBsb2dpY2FsIG5vLW9wLCBidXQgcmVkaXMgY2Fubm90IHNldCBleHBpcmUgdGltZSBvZiB6ZXJvXG4gICAgfVxuICAgIGlmICh0dGwgPCAwIHx8IGlzTmFOKHR0bCkpIHtcbiAgICAgIHR0bCA9IERFRkFVTFRfUkVESVNfVFRMO1xuICAgIH1cbiAgICB0aGlzLnAgPSB0aGlzLnAudGhlbigoKSA9PiB7XG4gICAgICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHtcbiAgICAgICAgaWYgKHR0bCA9PT0gSW5maW5pdHkpIHtcbiAgICAgICAgICB0aGlzLmNsaWVudC5zZXQoa2V5LCB2YWx1ZSwgZnVuY3Rpb24oKSB7XG4gICAgICAgICAgICByZXNvbHZlKCk7XG4gICAgICAgICAgfSk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgdGhpcy5jbGllbnQucHNldGV4KGtleSwgdHRsLCB2YWx1ZSwgZnVuY3Rpb24oKSB7XG4gICAgICAgICAgICByZXNvbHZlKCk7XG4gICAgICAgICAgfSk7XG4gICAgICAgIH1cbiAgICAgIH0pO1xuICAgIH0pO1xuICAgIHJldHVybiB0aGlzLnA7XG4gIH1cblxuICBkZWwoa2V5KSB7XG4gICAgZGVidWcoJ2RlbCcsIGtleSk7XG4gICAgdGhpcy5wID0gdGhpcy5wLnRoZW4oKCkgPT4ge1xuICAgICAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7XG4gICAgICAgIHRoaXMuY2xpZW50LmRlbChrZXksIGZ1bmN0aW9uKCkge1xuICAgICAgICAgIHJlc29sdmUoKTtcbiAgICAgICAgfSk7XG4gICAgICB9KTtcbiAgICB9KTtcbiAgICByZXR1cm4gdGhpcy5wO1xuICB9XG5cbiAgY2xlYXIoKSB7XG4gICAgZGVidWcoJ2NsZWFyJyk7XG4gICAgdGhpcy5wID0gdGhpcy5wLnRoZW4oKCkgPT4ge1xuICAgICAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7XG4gICAgICAgIHRoaXMuY2xpZW50LmZsdXNoZGIoZnVuY3Rpb24oKSB7XG4gICAgICAgICAgcmVzb2x2ZSgpO1xuICAgICAgICB9KTtcbiAgICAgIH0pO1xuICAgIH0pO1xuICAgIHJldHVybiB0aGlzLnA7XG4gIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgUmVkaXNDYWNoZUFkYXB0ZXI7XG4iXX0= \ No newline at end of file diff --git a/lib/Adapters/Email/MailAdapter.js b/lib/Adapters/Email/MailAdapter.js index b2fe018c92..24e6230d0b 100644 --- a/lib/Adapters/Email/MailAdapter.js +++ b/lib/Adapters/Email/MailAdapter.js @@ -26,4 +26,5 @@ class MailAdapter { } exports.MailAdapter = MailAdapter; -exports.default = MailAdapter; \ No newline at end of file +exports.default = MailAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9FbWFpbC9NYWlsQWRhcHRlci5qcyJdLCJuYW1lcyI6WyJNYWlsQWRhcHRlciIsInNlbmRNYWlsIiwib3B0aW9ucyJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQUNBOzs7O0FBSU8sTUFBTUEsV0FBTixDQUFrQjtBQUN2Qjs7Ozs7OztBQU9BQyxXQUFTQyxPQUFULEVBQWtCLENBQUU7O0FBRXBCOzs7QUFHQTtBQUNBO0FBZHVCOztRQUFaRixXLEdBQUFBLFc7a0JBaUJFQSxXIiwiZmlsZSI6Ik1haWxBZGFwdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyplc2xpbnQgbm8tdW51c2VkLXZhcnM6IFwib2ZmXCIqL1xuLypcbiAgTWFpbCBBZGFwdGVyIHByb3RvdHlwZVxuICBBIE1haWxBZGFwdGVyIHNob3VsZCBpbXBsZW1lbnQgYXQgbGVhc3Qgc2VuZE1haWwoKVxuICovXG5leHBvcnQgY2xhc3MgTWFpbEFkYXB0ZXIge1xuICAvKlxuICAgKiBBIG1ldGhvZCBmb3Igc2VuZGluZyBtYWlsXG4gICAqIEBwYXJhbSBvcHRpb25zIHdvdWxkIGhhdmUgdGhlIHBhcmFtZXRlcnNcbiAgICogLSB0bzogdGhlIHJlY2lwaWVudFxuICAgKiAtIHRleHQ6IHRoZSByYXcgdGV4dCBvZiB0aGUgbWVzc2FnZVxuICAgKiAtIHN1YmplY3Q6IHRoZSBzdWJqZWN0IG9mIHRoZSBlbWFpbFxuICAgKi9cbiAgc2VuZE1haWwob3B0aW9ucykge31cblxuICAvKiBZb3UgY2FuIGltcGxlbWVudCB0aG9zZSBtZXRob2RzIGlmIHlvdSB3YW50XG4gICAqIHRvIHByb3ZpZGUgSFRNTCB0ZW1wbGF0ZXMgZXRjLi4uXG4gICAqL1xuICAvLyBzZW5kVmVyaWZpY2F0aW9uRW1haWwoeyBsaW5rLCBhcHBOYW1lLCB1c2VyIH0pIHt9XG4gIC8vIHNlbmRQYXNzd29yZFJlc2V0RW1haWwoeyBsaW5rLCBhcHBOYW1lLCB1c2VyIH0pIHt9XG59XG5cbmV4cG9ydCBkZWZhdWx0IE1haWxBZGFwdGVyO1xuIl19 \ No newline at end of file diff --git a/lib/Adapters/Files/FilesAdapter.js b/lib/Adapters/Files/FilesAdapter.js index 128cb2cd94..eb8230f6e6 100644 --- a/lib/Adapters/Files/FilesAdapter.js +++ b/lib/Adapters/Files/FilesAdapter.js @@ -57,4 +57,5 @@ exports.FilesAdapter = FilesAdapter; /*eslint no-unused-vars: "off"*/ // and for the API server to be using the DatabaseController with Mongo // database adapter. -exports.default = FilesAdapter; \ No newline at end of file +exports.default = FilesAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Files/GridStoreAdapter.js b/lib/Adapters/Files/GridStoreAdapter.js index 355f2779dc..c872fff25b 100644 --- a/lib/Adapters/Files/GridStoreAdapter.js +++ b/lib/Adapters/Files/GridStoreAdapter.js @@ -88,4 +88,5 @@ exports.GridStoreAdapter = GridStoreAdapter; /** // -disable-next -exports.default = GridStoreAdapter; \ No newline at end of file +exports.default = GridStoreAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Logger/LoggerAdapter.js b/lib/Adapters/Logger/LoggerAdapter.js index 097955b9d4..d9504544ec 100644 --- a/lib/Adapters/Logger/LoggerAdapter.js +++ b/lib/Adapters/Logger/LoggerAdapter.js @@ -19,4 +19,5 @@ class LoggerAdapter { } exports.LoggerAdapter = LoggerAdapter; -exports.default = LoggerAdapter; \ No newline at end of file +exports.default = LoggerAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9Mb2dnZXIvTG9nZ2VyQWRhcHRlci5qcyJdLCJuYW1lcyI6WyJMb2dnZXJBZGFwdGVyIiwiY29uc3RydWN0b3IiLCJvcHRpb25zIiwibG9nIiwibGV2ZWwiLCJtZXNzYWdlIl0sIm1hcHBpbmdzIjoiOzs7OztBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTs7QUFFTyxNQUFNQSxhQUFOLENBQW9CO0FBQ3pCQyxjQUFZQyxPQUFaLEVBQXFCLENBQUU7QUFDdkJDLE1BQUlDLEtBQUosRUFBV0MsT0FBWCxFQUFvQixVQUFZLENBQUU7QUFGVDs7UUFBZEwsYSxHQUFBQSxhO2tCQUtFQSxhIiwiZmlsZSI6IkxvZ2dlckFkYXB0ZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKmVzbGludCBuby11bnVzZWQtdmFyczogXCJvZmZcIiovXG4vLyBMb2dnZXIgQWRhcHRlclxuLy9cbi8vIEFsbG93cyB5b3UgdG8gY2hhbmdlIHRoZSBsb2dnZXIgbWVjaGFuaXNtXG4vL1xuLy8gQWRhcHRlciBjbGFzc2VzIG11c3QgaW1wbGVtZW50IHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zOlxuLy8gKiBsb2coKSB7fVxuLy8gKiBxdWVyeShvcHRpb25zLCBjYWxsYmFjaykgLyogb3B0aW9uYWwgKi9cbi8vIERlZmF1bHQgaXMgV2luc3RvbkxvZ2dlckFkYXB0ZXIuanNcblxuZXhwb3J0IGNsYXNzIExvZ2dlckFkYXB0ZXIge1xuICBjb25zdHJ1Y3RvcihvcHRpb25zKSB7fVxuICBsb2cobGV2ZWwsIG1lc3NhZ2UsIC8qIG1ldGEgKi8pIHt9XG59XG5cbmV4cG9ydCBkZWZhdWx0IExvZ2dlckFkYXB0ZXI7XG4iXX0= \ No newline at end of file diff --git a/lib/Adapters/Logger/WinstonLogger.js b/lib/Adapters/Logger/WinstonLogger.js index bda6f18ea8..25baf58959 100644 --- a/lib/Adapters/Logger/WinstonLogger.js +++ b/lib/Adapters/Logger/WinstonLogger.js @@ -122,4 +122,5 @@ function removeTransport(transport) { } exports.logger = logger; -exports.default = logger; \ No newline at end of file +exports.default = logger; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Logger/WinstonLoggerAdapter.js b/lib/Adapters/Logger/WinstonLoggerAdapter.js index 0ea0a02cf7..13b1e7dff2 100644 --- a/lib/Adapters/Logger/WinstonLoggerAdapter.js +++ b/lib/Adapters/Logger/WinstonLoggerAdapter.js @@ -68,4 +68,5 @@ class WinstonLoggerAdapter extends _LoggerAdapter.LoggerAdapter { } exports.WinstonLoggerAdapter = WinstonLoggerAdapter; -exports.default = WinstonLoggerAdapter; \ No newline at end of file +exports.default = WinstonLoggerAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/MessageQueue/EventEmitterMQ.js b/lib/Adapters/MessageQueue/EventEmitterMQ.js index c25e1c2076..8213076ae7 100644 --- a/lib/Adapters/MessageQueue/EventEmitterMQ.js +++ b/lib/Adapters/MessageQueue/EventEmitterMQ.js @@ -69,4 +69,5 @@ const EventEmitterMQ = { createSubscriber }; -exports.EventEmitterMQ = EventEmitterMQ; \ No newline at end of file +exports.EventEmitterMQ = EventEmitterMQ; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/PubSub/EventEmitterPubSub.js b/lib/Adapters/PubSub/EventEmitterPubSub.js index b878353d74..57e2e8a915 100644 --- a/lib/Adapters/PubSub/EventEmitterPubSub.js +++ b/lib/Adapters/PubSub/EventEmitterPubSub.js @@ -62,4 +62,5 @@ const EventEmitterPubSub = { createSubscriber }; -exports.EventEmitterPubSub = EventEmitterPubSub; \ No newline at end of file +exports.EventEmitterPubSub = EventEmitterPubSub; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/PubSub/RedisPubSub.js b/lib/Adapters/PubSub/RedisPubSub.js index bb84311735..450baf503f 100644 --- a/lib/Adapters/PubSub/RedisPubSub.js +++ b/lib/Adapters/PubSub/RedisPubSub.js @@ -65,4 +65,5 @@ const RedisPubSub = { exports.RedisPubSub = RedisPubSub; exports.createPublisher = createPublisher; -exports.createSubscriber = createSubscriber; \ No newline at end of file +exports.createSubscriber = createSubscriber; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Push/PushAdapter.js b/lib/Adapters/Push/PushAdapter.js index d8080c5328..39bcf60093 100644 --- a/lib/Adapters/Push/PushAdapter.js +++ b/lib/Adapters/Push/PushAdapter.js @@ -29,4 +29,5 @@ class PushAdapter { } exports.PushAdapter = PushAdapter; -exports.default = PushAdapter; \ No newline at end of file +exports.default = PushAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9QdXNoL1B1c2hBZGFwdGVyLmpzIl0sIm5hbWVzIjpbIlB1c2hBZGFwdGVyIiwic2VuZCIsImJvZHkiLCJpbnN0YWxsYXRpb25zIiwicHVzaFN0YXR1cyIsImdldFZhbGlkUHVzaFR5cGVzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQUVPLE1BQU1BLFdBQU4sQ0FBa0I7QUFDdkJDLE9BQUtDLElBQUwsRUFBZ0JDLGFBQWhCLEVBQXNDQyxVQUF0QyxFQUFvRSxDQUFFOztBQUV0RTs7OztBQUlBQyxzQkFBOEI7QUFDNUIsV0FBTyxFQUFQO0FBQ0Q7QUFUc0I7O1FBQVpMLFcsR0FBQUEsVztrQkFZRUEsVyIsImZpbGUiOiJQdXNoQWRhcHRlci5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEBmbG93XG4vKmVzbGludCBuby11bnVzZWQtdmFyczogXCJvZmZcIiovXG4vLyBQdXNoIEFkYXB0ZXJcbi8vXG4vLyBBbGxvd3MgeW91IHRvIGNoYW5nZSB0aGUgcHVzaCBub3RpZmljYXRpb24gbWVjaGFuaXNtLlxuLy9cbi8vIEFkYXB0ZXIgY2xhc3NlcyBtdXN0IGltcGxlbWVudCB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uczpcbi8vICogZ2V0VmFsaWRQdXNoVHlwZXMoKVxuLy8gKiBzZW5kKGRldmljZXMsIGluc3RhbGxhdGlvbnMsIHB1c2hTdGF0dXMpXG4vL1xuLy8gRGVmYXVsdCBpcyBQYXJzZVB1c2hBZGFwdGVyLCB3aGljaCB1c2VzIEdDTSBmb3Jcbi8vIGFuZHJvaWQgcHVzaCBhbmQgQVBOUyBmb3IgaW9zIHB1c2guXG5cbmV4cG9ydCBjbGFzcyBQdXNoQWRhcHRlciB7XG4gIHNlbmQoYm9keTogYW55LCBpbnN0YWxsYXRpb25zOiBhbnlbXSwgcHVzaFN0YXR1czogYW55KTogP1Byb21pc2U8Kj4ge31cblxuICAvKipcbiAgICogR2V0IGFuIGFycmF5IG9mIHZhbGlkIHB1c2ggdHlwZXMuXG4gICAqIEByZXR1cm5zIHtBcnJheX0gQW4gYXJyYXkgb2YgdmFsaWQgcHVzaCB0eXBlc1xuICAgKi9cbiAgZ2V0VmFsaWRQdXNoVHlwZXMoKTogc3RyaW5nW10ge1xuICAgIHJldHVybiBbXVxuICB9XG59XG5cbmV4cG9ydCBkZWZhdWx0IFB1c2hBZGFwdGVyO1xuIl19 \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoCollection.js b/lib/Adapters/Storage/Mongo/MongoCollection.js index 7e9c22c2b6..e24eb7354a 100644 --- a/lib/Adapters/Storage/Mongo/MongoCollection.js +++ b/lib/Adapters/Storage/Mongo/MongoCollection.js @@ -109,4 +109,5 @@ class MongoCollection { return this._mongoCollection.drop(); } } -exports.default = MongoCollection; \ No newline at end of file +exports.default = MongoCollection; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoCollection.js"],"names":["mongodb","require","Collection","MongoCollection","constructor","mongoCollection","_mongoCollection","find","query","skip","limit","sort","keys","maxTimeMS","readPreference","$score","score","$meta","_rawFind","catch","error","code","message","match","key","index","createIndex","then","findOperation","project","toArray","count","countOperation","distinct","field","aggregate","pipeline","insertOne","object","upsertOne","update","upsert","updateOne","updateMany","deleteMany","_ensureSparseUniqueIndexInBackground","indexRequest","Promise","resolve","reject","ensureIndex","unique","background","sparse","drop"],"mappings":"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","file":"MongoCollection.js","sourcesContent":["const mongodb = require('mongodb');\nconst Collection = mongodb.Collection;\n\nexport default class MongoCollection {\n  _mongoCollection:Collection;\n\n  constructor(mongoCollection:Collection) {\n    this._mongoCollection = mongoCollection;\n  }\n\n  // Does a find with \"smart indexing\".\n  // Currently this just means, if it needs a geoindex and there is\n  // none, then build the geoindex.\n  // This could be improved a lot but it's not clear if that's a good\n  // idea. Or even if this behavior is a good idea.\n  find(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) {\n    // Support for Full Text Search - $text\n    if(keys && keys.$score) {\n      delete keys.$score;\n      keys.score = {$meta: 'textScore'};\n    }\n    return this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference })\n      .catch(error => {\n        // Check for \"no geoindex\" error\n        if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {\n          throw error;\n        }\n        // Figure out what key needs an index\n        const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];\n        if (!key) {\n          throw error;\n        }\n\n        var index = {};\n        index[key] = '2d';\n        return this._mongoCollection.createIndex(index)\n          // Retry, but just once.\n          .then(() => this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference }));\n      });\n  }\n\n  _rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) {\n    let findOperation = this._mongoCollection\n      .find(query, { skip, limit, sort, readPreference })\n\n    if (keys) {\n      findOperation = findOperation.project(keys);\n    }\n\n    if (maxTimeMS) {\n      findOperation = findOperation.maxTimeMS(maxTimeMS);\n    }\n\n    return findOperation.toArray();\n  }\n\n  count(query, { skip, limit, sort, maxTimeMS, readPreference } = {}) {\n    const countOperation = this._mongoCollection.count(query, { skip, limit, sort, maxTimeMS, readPreference });\n\n    return countOperation;\n  }\n\n  distinct(field, query) {\n    return this._mongoCollection.distinct(field, query);\n  }\n\n  aggregate(pipeline, { maxTimeMS, readPreference } = {}) {\n    return this._mongoCollection.aggregate(pipeline, { maxTimeMS, readPreference }).toArray();\n  }\n\n  insertOne(object) {\n    return this._mongoCollection.insertOne(object);\n  }\n\n  // Atomically updates data in the database for a single (first) object that matched the query\n  // If there is nothing that matches the query - does insert\n  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.\n  upsertOne(query, update) {\n    return this._mongoCollection.update(query, update, { upsert: true })\n  }\n\n  updateOne(query, update) {\n    return this._mongoCollection.updateOne(query, update);\n  }\n\n  updateMany(query, update) {\n    return this._mongoCollection.updateMany(query, update);\n  }\n\n  deleteMany(query) {\n    return this._mongoCollection.deleteMany(query);\n  }\n\n  _ensureSparseUniqueIndexInBackground(indexRequest) {\n    return new Promise((resolve, reject) => {\n      this._mongoCollection.ensureIndex(indexRequest, { unique: true, background: true, sparse: true }, (error) => {\n        if (error) {\n          reject(error);\n        } else {\n          resolve();\n        }\n      });\n    });\n  }\n\n  drop() {\n    return this._mongoCollection.drop();\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js b/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js index c8b35c71ef..1335b2b1a2 100644 --- a/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js +++ b/lib/Adapters/Storage/Mongo/MongoSchemaCollection.js @@ -235,4 +235,5 @@ class MongoSchemaCollection { MongoSchemaCollection._TESTmongoSchemaToParseSchema = mongoSchemaToParseSchema; MongoSchemaCollection.parseFieldTypeToMongoFieldType = parseFieldTypeToMongoFieldType; -exports.default = MongoSchemaCollection; \ No newline at end of file +exports.default = MongoSchemaCollection; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoSchemaCollection.js"],"names":["mongoFieldToParseSchemaField","type","targetClass","slice","startsWith","length","nonFieldSchemaKeys","mongoSchemaFieldsToParseSchemaFields","schema","fieldNames","Object","keys","filter","key","indexOf","response","reduce","obj","fieldName","ACL","createdAt","updatedAt","objectId","emptyCLPS","freeze","find","get","create","update","delete","addField","defaultCLPS","mongoSchemaToParseSchema","mongoSchema","clps","indexes","_metadata","class_permissions","className","_id","fields","classLevelPermissions","_mongoSchemaQueryFromNameQuery","name","query","object","forEach","parseFieldTypeToMongoFieldType","MongoSchemaCollection","constructor","collection","_collection","_fetchAllSchemasFrom_SCHEMA","_rawFind","then","schemas","map","_fetchOneSchemaFrom_SCHEMA","limit","results","undefined","findAndDeleteSchema","_mongoCollection","findAndRemove","insertSchema","insertOne","result","ops","catch","error","code","Parse","Error","DUPLICATE_VALUE","updateSchema","updateOne","upsertSchema","upsertOne","addFieldIfNotExists","some","existingField","INCORRECT_TYPE","_TESTmongoSchemaToParseSchema"],"mappings":"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","file":"MongoSchemaCollection.js","sourcesContent":["import MongoCollection from './MongoCollection';\nimport Parse           from 'parse/node';\n\nfunction mongoFieldToParseSchemaField(type) {\n  if (type[0] === '*') {\n    return {\n      type: 'Pointer',\n      targetClass: type.slice(1),\n    };\n  }\n  if (type.startsWith('relation<')) {\n    return {\n      type: 'Relation',\n      targetClass: type.slice('relation<'.length, type.length - 1),\n    };\n  }\n  switch (type) {\n  case 'number':   return {type: 'Number'};\n  case 'string':   return {type: 'String'};\n  case 'boolean':  return {type: 'Boolean'};\n  case 'date':     return {type: 'Date'};\n  case 'map':\n  case 'object':   return {type: 'Object'};\n  case 'array':    return {type: 'Array'};\n  case 'geopoint': return {type: 'GeoPoint'};\n  case 'file':     return {type: 'File'};\n  case 'bytes':    return {type: 'Bytes'};\n  case 'polygon':  return {type: 'Polygon'};\n  }\n}\n\nconst nonFieldSchemaKeys = ['_id', '_metadata', '_client_permissions'];\nfunction mongoSchemaFieldsToParseSchemaFields(schema) {\n  var fieldNames = Object.keys(schema).filter(key => nonFieldSchemaKeys.indexOf(key) === -1);\n  var response = fieldNames.reduce((obj, fieldName) => {\n    obj[fieldName] = mongoFieldToParseSchemaField(schema[fieldName])\n    return obj;\n  }, {});\n  response.ACL = {type: 'ACL'};\n  response.createdAt = {type: 'Date'};\n  response.updatedAt = {type: 'Date'};\n  response.objectId = {type: 'String'};\n  return response;\n}\n\nconst emptyCLPS = Object.freeze({\n  find: {},\n  get: {},\n  create: {},\n  update: {},\n  delete: {},\n  addField: {},\n});\n\nconst defaultCLPS = Object.freeze({\n  find: {'*': true},\n  get: {'*': true},\n  create: {'*': true},\n  update: {'*': true},\n  delete: {'*': true},\n  addField: {'*': true},\n});\n\nfunction mongoSchemaToParseSchema(mongoSchema) {\n  let clps = defaultCLPS;\n  let indexes = {}\n  if (mongoSchema._metadata) {\n    if (mongoSchema._metadata.class_permissions) {\n      clps = {...emptyCLPS, ...mongoSchema._metadata.class_permissions};\n    }\n    if (mongoSchema._metadata.indexes) {\n      indexes = {...mongoSchema._metadata.indexes};\n    }\n  }\n  return {\n    className: mongoSchema._id,\n    fields: mongoSchemaFieldsToParseSchemaFields(mongoSchema),\n    classLevelPermissions: clps,\n    indexes: indexes,\n  };\n}\n\nfunction _mongoSchemaQueryFromNameQuery(name: string, query) {\n  const object = { _id: name };\n  if (query) {\n    Object.keys(query).forEach(key => {\n      object[key] = query[key];\n    });\n  }\n  return object;\n}\n\n\n// Returns a type suitable for inserting into mongo _SCHEMA collection.\n// Does no validation. That is expected to be done in Parse Server.\nfunction parseFieldTypeToMongoFieldType({ type, targetClass }) {\n  switch (type) {\n  case 'Pointer':  return `*${targetClass}`;\n  case 'Relation': return `relation<${targetClass}>`;\n  case 'Number':   return 'number';\n  case 'String':   return 'string';\n  case 'Boolean':  return 'boolean';\n  case 'Date':     return 'date';\n  case 'Object':   return 'object';\n  case 'Array':    return 'array';\n  case 'GeoPoint': return 'geopoint';\n  case 'File':     return 'file';\n  case 'Bytes':    return 'bytes';\n  case 'Polygon':  return 'polygon';\n  }\n}\n\nclass MongoSchemaCollection {\n  _collection: MongoCollection;\n\n  constructor(collection: MongoCollection) {\n    this._collection = collection;\n  }\n\n  _fetchAllSchemasFrom_SCHEMA() {\n    return this._collection._rawFind({})\n      .then(schemas => schemas.map(mongoSchemaToParseSchema));\n  }\n\n  _fetchOneSchemaFrom_SCHEMA(name: string) {\n    return this._collection._rawFind(_mongoSchemaQueryFromNameQuery(name), { limit: 1 }).then(results => {\n      if (results.length === 1) {\n        return mongoSchemaToParseSchema(results[0]);\n      } else {\n        throw undefined;\n      }\n    });\n  }\n\n  // Atomically find and delete an object based on query.\n  findAndDeleteSchema(name: string) {\n    return this._collection._mongoCollection.findAndRemove(_mongoSchemaQueryFromNameQuery(name), []);\n  }\n\n  insertSchema(schema: any) {\n    return this._collection.insertOne(schema)\n      .then(result => mongoSchemaToParseSchema(result.ops[0]))\n      .catch(error => {\n        if (error.code === 11000) { //Mongo's duplicate key error\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Class already exists.');\n        } else {\n          throw error;\n        }\n      })\n  }\n\n  updateSchema(name: string, update) {\n    return this._collection.updateOne(_mongoSchemaQueryFromNameQuery(name), update);\n  }\n\n  upsertSchema(name: string, query: string, update) {\n    return this._collection.upsertOne(_mongoSchemaQueryFromNameQuery(name, query), update);\n  }\n\n  // Add a field to the schema. If database does not support the field\n  // type (e.g. mongo doesn't support more than one GeoPoint in a class) reject with an \"Incorrect Type\"\n  // Parse error with a desciptive message. If the field already exists, this function must\n  // not modify the schema, and must reject with DUPLICATE_VALUE error.\n  // If this is called for a class that doesn't exist, this function must create that class.\n\n  // TODO: throw an error if an unsupported field type is passed. Deciding whether a type is supported\n  // should be the job of the adapter. Some adapters may not support GeoPoint at all. Others may\n  // Support additional types that Mongo doesn't, like Money, or something.\n\n  // TODO: don't spend an extra query on finding the schema if the type we are trying to add isn't a GeoPoint.\n  addFieldIfNotExists(className: string, fieldName: string, type: string) {\n    return this._fetchOneSchemaFrom_SCHEMA(className)\n      .then(schema => {\n        // If a field with this name already exists, it will be handled elsewhere.\n        if (schema.fields[fieldName] != undefined) {\n          return;\n        }\n        // The schema exists. Check for existing GeoPoints.\n        if (type.type === 'GeoPoint') {\n        // Make sure there are not other geopoint fields\n          if (Object.keys(schema.fields).some(existingField => schema.fields[existingField].type === 'GeoPoint')) {\n            throw new Parse.Error(Parse.Error.INCORRECT_TYPE, 'MongoDB only supports one GeoPoint field in a class.');\n          }\n        }\n        return;\n      }, error => {\n      // If error is undefined, the schema doesn't exist, and we can create the schema with the field.\n      // If some other error, reject with it.\n        if (error === undefined) {\n          return;\n        }\n        throw error;\n      })\n      .then(() => {\n      // We use $exists and $set to avoid overwriting the field type if it\n      // already exists. (it could have added inbetween the last query and the update)\n        return this.upsertSchema(\n          className,\n          { [fieldName]: { '$exists': false } },\n          { '$set' : { [fieldName]: parseFieldTypeToMongoFieldType(type) } }\n        );\n      });\n  }\n}\n\n// Exported for testing reasons and because we haven't moved all mongo schema format\n// related logic into the database adapter yet.\nMongoSchemaCollection._TESTmongoSchemaToParseSchema = mongoSchemaToParseSchema\nMongoSchemaCollection.parseFieldTypeToMongoFieldType = parseFieldTypeToMongoFieldType\n\nexport default MongoSchemaCollection\n"]} \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js index b93ae9facd..dbd8421b3c 100644 --- a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -301,9 +301,8 @@ class MongoStorageAdapter { .then(() => this._schemaCollection()).then(schemaCollection => schemaCollection.findAndDeleteSchema(className)).catch(err => this.handleError(err)); } - // Delete all data known to this adapter. Used for testing. - deleteAllClasses() { - return storageAdapterAllCollections(this).then(collections => Promise.all(collections.map(collection => collection.drop()))).catch(err => this.handleError(err)); + deleteAllClasses(fast) { + return storageAdapterAllCollections(this).then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop()))); } // Remove the column and all the data. For Relations, the _Join collection is handled @@ -511,26 +510,17 @@ class MongoStorageAdapter { aggregate(className, schema, pipeline, readPreference) { let isPointerField = false; pipeline = pipeline.map(stage => { - if (stage.$group && stage.$group._id && typeof stage.$group._id === 'string') { - const field = stage.$group._id.substring(1); - if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + if (stage.$group) { + stage.$group = this._parseAggregateGroupArgs(schema, stage.$group); + if (stage.$group._id && typeof stage.$group._id === 'string' && stage.$group._id.indexOf('$_p_') >= 0) { isPointerField = true; - stage.$group._id = `$_p_${field}`; } } if (stage.$match) { - for (const field in stage.$match) { - if (schema.fields[field] && schema.fields[field].type === 'Pointer') { - const transformMatch = { [`_p_${field}`]: `${className}$${stage.$match[field]}` }; - stage.$match = transformMatch; - } - if (field === 'objectId') { - const transformMatch = Object.assign({}, stage.$match); - transformMatch._id = stage.$match[field]; - delete transformMatch.objectId; - stage.$match = transformMatch; - } - } + stage.$match = this._parseAggregateArgs(schema, stage.$match); + } + if (stage.$project) { + stage.$project = this._parseAggregateProjectArgs(schema, stage.$project); } return stage; }); @@ -557,6 +547,130 @@ class MongoStorageAdapter { }).then(objects => objects.map(object => (0, _MongoTransform.mongoObjectToParseObject)(className, object, schema))).catch(err => this.handleError(err)); } + // This function will recursively traverse the pipeline and convert any Pointer or Date columns. + // If we detect a pointer column we will rename the column being queried for to match the column + // in the database. We also modify the value to what we expect the value to be in the database + // as well. + // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert + // the string to a Date so the driver can perform the necessary comparison. + // + // The goal of this method is to look for the "leaves" of the pipeline and determine if it needs + // to be converted. The pipeline can have a few different forms. For more details, see: + // https://docs.mongodb.com/manual/reference/operator/aggregation/ + // + // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In + // that case we need to loop through all of it's children to find the columns being operated on. + // If the pipeline is an object, then we'll loop through the keys checking to see if the key name + // matches one of the schema columns. If it does match a column and the column is a Pointer or + // a Date, then we'll convert the value as described above. + // + // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing + // down a tree to find a "leaf node" and checking to see if it needs to be converted. + _parseAggregateArgs(schema, pipeline) { + if (Array.isArray(pipeline)) { + return pipeline.map(value => this._parseAggregateArgs(schema, value)); + } else if (typeof pipeline === 'object') { + const returnValue = {}; + for (const field in pipeline) { + if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + if (typeof pipeline[field] === 'object') { + // Pass objects down to MongoDB...this is more than likely an $exists operator. + returnValue[`_p_${field}`] = pipeline[field]; + } else { + returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`; + } + } else if (schema.fields[field] && schema.fields[field].type === 'Date') { + returnValue[field] = this._convertToDate(pipeline[field]); + } else { + returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]); + } + + if (field === 'objectId') { + returnValue['_id'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'createdAt') { + returnValue['_created_at'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'updatedAt') { + returnValue['_updated_at'] = returnValue[field]; + delete returnValue[field]; + } + } + return returnValue; + } + return pipeline; + } + + // This function is slightly different than the one above. Rather than trying to combine these + // two functions and making the code even harder to understand, I decided to split it up. The + // difference with this function is we are not transforming the values, only the keys of the + // pipeline. + _parseAggregateProjectArgs(schema, pipeline) { + const returnValue = {}; + for (const field in pipeline) { + if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + returnValue[`_p_${field}`] = pipeline[field]; + } else { + returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]); + } + + if (field === 'objectId') { + returnValue['_id'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'createdAt') { + returnValue['_created_at'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'updatedAt') { + returnValue['_updated_at'] = returnValue[field]; + delete returnValue[field]; + } + } + return returnValue; + } + + // This function is slightly different than the two above. MongoDB $group aggregate looks like: + // { $group: { _id: , : { : }, ... } } + // The could be a column name, prefixed with the '$' character. We'll look for + // these and check to see if it is a 'Pointer' or if it's one of createdAt, + // updatedAt or objectId and change it accordingly. + _parseAggregateGroupArgs(schema, pipeline) { + if (Array.isArray(pipeline)) { + return pipeline.map(value => this._parseAggregateGroupArgs(schema, value)); + } else if (typeof pipeline === 'object') { + const returnValue = {}; + for (const field in pipeline) { + returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]); + } + return returnValue; + } else if (typeof pipeline === 'string') { + const field = pipeline.substring(1); + if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + return `$_p_${field}`; + } else if (field == 'createdAt') { + return '$_created_at'; + } else if (field == 'updatedAt') { + return '$_updated_at'; + } + } + return pipeline; + } + + // This function will attempt to convert the provided value to a Date object. Since this is part + // of an aggregation pipeline, the value can either be a string or it can be another object with + // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a + // recursive method to traverse down to the "leaf node" which is going to be the string. + _convertToDate(value) { + if (typeof value === 'string') { + return new Date(value); + } + + const returnValue = {}; + for (const field in value) { + returnValue[field] = this._convertToDate(value[field]); + } + return returnValue; + } + _parseReadPreference(readPreference) { switch (readPreference) { case 'PRIMARY': @@ -575,8 +689,6 @@ class MongoStorageAdapter { readPreference = ReadPreference.NEAREST; break; case undefined: - // this is to match existing tests, which were failing as mongodb@3.0 don't report readPreference anymore - readPreference = ReadPreference.PRIMARY; break; default: throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, 'Not supported read preference.'); @@ -656,4 +768,5 @@ class MongoStorageAdapter { } exports.MongoStorageAdapter = MongoStorageAdapter; -exports.default = MongoStorageAdapter; \ No newline at end of file +exports.default = MongoStorageAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoStorageAdapter.js"],"names":["mongodb","require","MongoClient","ReadPreference","MongoSchemaCollectionName","storageAdapterAllCollections","mongoAdapter","connect","then","database","collections","filter","collection","namespace","match","collectionName","indexOf","_collectionPrefix","convertParseSchemaToMongoSchema","schema","fields","_rperm","_wperm","className","_hashed_password","mongoSchemaFromFieldsAndClassNameAndCLP","classLevelPermissions","indexes","mongoObject","_id","objectId","updatedAt","createdAt","_metadata","undefined","fieldName","MongoSchemaCollection","parseFieldTypeToMongoFieldType","class_permissions","Object","keys","length","MongoStorageAdapter","constructor","uri","defaults","DefaultMongoURI","collectionPrefix","mongoOptions","_uri","_mongoOptions","_maxTimeMS","maxTimeMS","canSortOnJoinTables","connectionPromise","encodedUri","client","options","s","db","dbName","on","catch","err","Promise","reject","handleError","error","code","logger","handleShutdown","close","_adaptiveCollection","name","rawCollection","MongoCollection","_schemaCollection","classExists","listCollections","toArray","setClassLevelPermissions","CLPs","schemaCollection","updateSchema","$set","setIndexesWithSchemaFormat","submittedIndexes","existingIndexes","resolve","_id_","deletePromises","insertedIndexes","forEach","field","__op","Parse","Error","INVALID_QUERY","promise","dropIndex","push","key","hasOwnProperty","insertPromise","createIndexes","all","setIndexesFromMongo","getIndexes","reduce","obj","index","_fts","_ftsx","weights","createClass","insertSchema","addFieldIfNotExists","type","createIndexesIfNeeded","deleteClass","drop","message","findAndDeleteSchema","deleteAllClasses","fast","map","remove","deleteFields","fieldNames","mongoFormatNames","collectionUpdate","schemaUpdate","updateMany","getAllClasses","schemasCollection","_fetchAllSchemasFrom_SCHEMA","getClass","_fetchOneSchemaFrom_SCHEMA","createObject","object","insertOne","DUPLICATE_VALUE","underlyingError","matches","Array","isArray","userInfo","duplicated_field","deleteObjectsByQuery","query","mongoWhere","deleteMany","result","n","OBJECT_NOT_FOUND","INTERNAL_SERVER_ERROR","updateObjectsByQuery","update","mongoUpdate","findOneAndUpdate","_mongoCollection","findAndModify","new","value","upsertOneObject","upsertOne","find","skip","limit","sort","readPreference","mongoSort","_","mapKeys","mongoKeys","memo","_parseReadPreference","createTextIndexesIfNeeded","objects","ensureUniqueness","indexCreationRequest","mongoFieldNames","_ensureSparseUniqueIndexInBackground","_rawFind","count","distinct","isPointerField","substring","aggregate","pipeline","stage","$group","_parseAggregateGroupArgs","$match","_parseAggregateArgs","$project","_parseAggregateProjectArgs","results","split","isEmpty","returnValue","targetClass","_convertToDate","Date","PRIMARY","PRIMARY_PREFERRED","SECONDARY","SECONDARY_PREFERRED","NEAREST","performInitialization","createIndex","background","$text","indexName","textIndex","dropAllIndexes","dropIndexes","updateSchemaWithIndexes","classes","promises"],"mappings":"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","file":"MongoStorageAdapter.js","sourcesContent":["// @flow\nimport MongoCollection       from './MongoCollection';\nimport MongoSchemaCollection from './MongoSchemaCollection';\nimport { StorageAdapter }    from '../StorageAdapter';\nimport type { SchemaType,\n  QueryType,\n  StorageClass,\n  QueryOptions } from '../StorageAdapter';\nimport {\n  parse as parseUrl,\n  format as formatUrl,\n} from '../../../vendor/mongodbUrl';\nimport {\n  parseObjectToMongoObjectForCreate,\n  mongoObjectToParseObject,\n  transformKey,\n  transformWhere,\n  transformUpdate,\n  transformPointerString,\n} from './MongoTransform';\n// @flow-disable-next\nimport Parse                 from 'parse/node';\n// @flow-disable-next\nimport _                     from 'lodash';\nimport defaults              from '../../../defaults';\nimport logger                from '../../../logger';\n\n// @flow-disable-next\nconst mongodb = require('mongodb');\nconst MongoClient = mongodb.MongoClient;\nconst ReadPreference = mongodb.ReadPreference;\n\nconst MongoSchemaCollectionName = '_SCHEMA';\n\nconst storageAdapterAllCollections = mongoAdapter => {\n  return mongoAdapter.connect()\n    .then(() => mongoAdapter.database.collections())\n    .then(collections => {\n      return collections.filter(collection => {\n        if (collection.namespace.match(/\\.system\\./)) {\n          return false;\n        }\n        // TODO: If you have one app with a collection prefix that happens to be a prefix of another\n        // apps prefix, this will go very very badly. We should fix that somehow.\n        return (collection.collectionName.indexOf(mongoAdapter._collectionPrefix) == 0);\n      });\n    });\n}\n\nconst convertParseSchemaToMongoSchema = ({...schema}) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  if (schema.className === '_User') {\n    // Legacy mongo adapter knows about the difference between password and _hashed_password.\n    // Future database adapters will only know about _hashed_password.\n    // Note: Parse Server will bring back password with injectDefaultSchema, so we don't need\n    // to add _hashed_password back ever.\n    delete schema.fields._hashed_password;\n  }\n\n  return schema;\n}\n\n// Returns { code, error } if invalid, or { result }, an object\n// suitable for inserting into _SCHEMA collection, otherwise.\nconst mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPermissions, indexes) => {\n  const mongoObject = {\n    _id: className,\n    objectId: 'string',\n    updatedAt: 'string',\n    createdAt: 'string',\n    _metadata: undefined,\n  };\n\n  for (const fieldName in fields) {\n    mongoObject[fieldName] = MongoSchemaCollection.parseFieldTypeToMongoFieldType(fields[fieldName]);\n  }\n\n  if (typeof classLevelPermissions !== 'undefined') {\n    mongoObject._metadata = mongoObject._metadata || {};\n    if (!classLevelPermissions) {\n      delete mongoObject._metadata.class_permissions;\n    } else {\n      mongoObject._metadata.class_permissions = classLevelPermissions;\n    }\n  }\n\n  if (indexes && typeof indexes === 'object' && Object.keys(indexes).length > 0) {\n    mongoObject._metadata = mongoObject._metadata || {};\n    mongoObject._metadata.indexes = indexes;\n  }\n\n  if (!mongoObject._metadata) { // cleanup the unused _metadata\n    delete mongoObject._metadata;\n  }\n\n  return mongoObject;\n}\n\n\nexport class MongoStorageAdapter implements StorageAdapter {\n  // Private\n  _uri: string;\n  _collectionPrefix: string;\n  _mongoOptions: Object;\n  // Public\n  connectionPromise: Promise<any>;\n  database: any;\n  client: MongoClient;\n  _maxTimeMS: ?number;\n  canSortOnJoinTables: boolean;\n\n  constructor({\n    uri = defaults.DefaultMongoURI,\n    collectionPrefix = '',\n    mongoOptions = {},\n  }: any) {\n    this._uri = uri;\n    this._collectionPrefix = collectionPrefix;\n    this._mongoOptions = mongoOptions;\n\n    // MaxTimeMS is not a global MongoDB client option, it is applied per operation.\n    this._maxTimeMS = mongoOptions.maxTimeMS;\n    this.canSortOnJoinTables = true;\n    delete mongoOptions.maxTimeMS;\n  }\n\n  connect() {\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    // parsing and re-formatting causes the auth value (if there) to get URI\n    // encoded\n    const encodedUri = formatUrl(parseUrl(this._uri));\n\n    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(client => {\n      // Starting mongoDB 3.0, the MongoClient.connect don't return a DB anymore but a client\n      // Fortunately, we can get back the options and use them to select the proper DB.\n      // https://github.com/mongodb/node-mongodb-native/blob/2c35d76f08574225b8db02d7bef687123e6bb018/lib/mongo_client.js#L885\n      const options = client.s.options;\n      const database = client.db(options.dbName);\n      if (!database) {\n        delete this.connectionPromise;\n        return;\n      }\n      database.on('error', () => {\n        delete this.connectionPromise;\n      });\n      database.on('close', () => {\n        delete this.connectionPromise;\n      });\n      this.client = client;\n      this.database = database;\n    }).catch((err) => {\n      delete this.connectionPromise;\n      return Promise.reject(err);\n    });\n\n    return this.connectionPromise;\n  }\n\n  handleError<T>(error: ?(Error | Parse.Error)): Promise<T> {\n    if (error && error.code === 13) { // Unauthorized error\n      delete this.client;\n      delete this.database;\n      delete this.connectionPromise;\n      logger.error('Received unauthorized error', { error: error });\n    }\n    throw error;\n  }\n\n  handleShutdown() {\n    if (!this.client) {\n      return;\n    }\n    this.client.close(false);\n  }\n\n  _adaptiveCollection(name: string) {\n    return this.connect()\n      .then(() => this.database.collection(this._collectionPrefix + name))\n      .then(rawCollection => new MongoCollection(rawCollection))\n      .catch(err => this.handleError(err));\n  }\n\n  _schemaCollection(): Promise<MongoSchemaCollection> {\n    return this.connect()\n      .then(() => this._adaptiveCollection(MongoSchemaCollectionName))\n      .then(collection => new MongoSchemaCollection(collection));\n  }\n\n  classExists(name: string) {\n    return this.connect().then(() => {\n      return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();\n    }).then(collections => {\n      return collections.length > 0;\n    }).catch(err => this.handleError(err));\n  }\n\n  setClassLevelPermissions(className: string, CLPs: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.class_permissions': CLPs }\n      })).catch(err => this.handleError(err));\n  }\n\n  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any): Promise<void> {\n    if (submittedIndexes === undefined) {\n      return Promise.resolve();\n    }\n    if (Object.keys(existingIndexes).length === 0) {\n      existingIndexes = { _id_: { _id: 1} };\n    }\n    const deletePromises = [];\n    const insertedIndexes = [];\n    Object.keys(submittedIndexes).forEach(name => {\n      const field = submittedIndexes[name];\n      if (existingIndexes[name] && field.__op !== 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`);\n      }\n      if (!existingIndexes[name] && field.__op === 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`);\n      }\n      if (field.__op === 'Delete') {\n        const promise = this.dropIndex(className, name);\n        deletePromises.push(promise);\n        delete existingIndexes[name];\n      } else {\n        Object.keys(field).forEach(key => {\n          if (!fields.hasOwnProperty(key)) {\n            throw new Parse.Error(Parse.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`);\n          }\n        });\n        existingIndexes[name] = field;\n        insertedIndexes.push({\n          key: field,\n          name,\n        });\n      }\n    });\n    let insertPromise = Promise.resolve();\n    if (insertedIndexes.length > 0) {\n      insertPromise = this.createIndexes(className, insertedIndexes);\n    }\n    return Promise.all(deletePromises)\n      .then(() => insertPromise)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.indexes':  existingIndexes }\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  setIndexesFromMongo(className: string) {\n    return this.getIndexes(className).then((indexes) => {\n      indexes = indexes.reduce((obj, index) => {\n        if (index.key._fts) {\n          delete index.key._fts;\n          delete index.key._ftsx;\n          for (const field in index.weights) {\n            index.key[field] = 'text';\n          }\n        }\n        obj[index.name] = index.key;\n        return obj;\n      }, {});\n      return this._schemaCollection()\n        .then(schemaCollection => schemaCollection.updateSchema(className, {\n          $set: { '_metadata.indexes': indexes }\n        }));\n    })\n      .catch(err => this.handleError(err))\n      .catch(() => {\n        // Ignore if collection not found\n        return Promise.resolve();\n      });\n  }\n\n  createClass(className: string, schema: SchemaType): Promise<void> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions, schema.indexes);\n    mongoObject._id = className;\n    return this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.insertSchema(mongoObject))\n      .catch(err => this.handleError(err));\n  }\n\n  addFieldIfNotExists(className: string, fieldName: string, type: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type))\n      .then(() => this.createIndexesIfNeeded(className, fieldName, type))\n      .catch(err => this.handleError(err));\n  }\n\n  // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)\n  // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.\n  deleteClass(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection.drop())\n      .catch(error => {\n      // 'ns not found' means collection was already gone. Ignore deletion attempt.\n        if (error.message == 'ns not found') {\n          return;\n        }\n        throw error;\n      })\n    // We've dropped the collection, now remove the _SCHEMA document\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.findAndDeleteSchema(className))\n      .catch(err => this.handleError(err));\n  }\n\n  deleteAllClasses(fast: boolean) {\n    return storageAdapterAllCollections(this)\n      .then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop())));\n  }\n\n  // Remove the column and all the data. For Relations, the _Join collection is handled\n  // specially, this function does not delete _Join columns. It should, however, indicate\n  // that the relation fields does not exist anymore. In mongo, this means removing it from\n  // the _SCHEMA collection.  There should be no actual data in the collection under the same name\n  // as the relation column, so it's fine to attempt to delete it. If the fields listed to be\n  // deleted do not exist, this function should return successfully anyways. Checking for\n  // attempts to delete non-existent fields is the responsibility of Parse Server.\n\n  // Pointer field names are passed for legacy reasons: the original mongo\n  // format stored pointer field names differently in the database, and therefore\n  // needed to know the type of the field before it could delete it. Future database\n  // adapters should ignore the pointerFieldNames argument. All the field names are in\n  // fieldNames, they show up additionally in the pointerFieldNames database for use\n  // by the mongo adapter, which deals with the legacy mongo format.\n\n  // This function is not obligated to delete fields atomically. It is given the field\n  // names in a list so that databases that are capable of deleting fields atomically\n  // may do so.\n\n  // Returns a Promise.\n  deleteFields(className: string, schema: SchemaType, fieldNames: string[]) {\n    const mongoFormatNames = fieldNames.map(fieldName => {\n      if (schema.fields[fieldName].type === 'Pointer') {\n        return `_p_${fieldName}`\n      } else {\n        return fieldName;\n      }\n    });\n    const collectionUpdate = { '$unset' : {} };\n    mongoFormatNames.forEach(name => {\n      collectionUpdate['$unset'][name] = null;\n    });\n\n    const schemaUpdate = { '$unset' : {} };\n    fieldNames.forEach(name => {\n      schemaUpdate['$unset'][name] = null;\n    });\n\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany({}, collectionUpdate))\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for all schemas known to this adapter, in Parse format. In case the\n  // schemas cannot be retrieved, returns a promise that rejects. Requirements for the\n  // rejection reason are TBD.\n  getAllClasses(): Promise<StorageClass[]> {\n    return this._schemaCollection().then(schemasCollection => schemasCollection._fetchAllSchemasFrom_SCHEMA())\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for the schema with the given name, in Parse format. If\n  // this adapter doesn't know about the schema, return a promise that rejects with\n  // undefined as the reason.\n  getClass(className: string): Promise<StorageClass> {\n    return this._schemaCollection()\n      .then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className))\n      .catch(err => this.handleError(err));\n  }\n\n  // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema,\n  // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs\n  // the schema only for the legacy mongo format. We'll figure that out later.\n  createObject(className: string, schema: SchemaType, object: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = parseObjectToMongoObjectForCreate(className, object, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.insertOne(mongoObject))\n      .catch(error => {\n        if (error.code === 11000) { // Duplicate value\n          const err = new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          err.underlyingError = error;\n          if (error.message) {\n            const matches = error.message.match(/index:[\\sa-zA-Z0-9_\\-\\.]+\\$?([a-zA-Z_-]+)_1/);\n            if (matches && Array.isArray(matches)) {\n              err.userInfo = { duplicated_field: matches[1] };\n            }\n          }\n          throw err;\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Remove all objects that match the given Parse Query.\n  // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.\n  // If there is some other error, reject with INTERNAL_SERVER_ERROR.\n  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    return this._adaptiveCollection(className)\n      .then(collection => {\n        const mongoWhere = transformWhere(className, query, schema);\n        return collection.deleteMany(mongoWhere)\n      })\n      .catch(err => this.handleError(err))\n      .then(({ result }) => {\n        if (result.n === 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n        return Promise.resolve();\n      }, () => {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error');\n      });\n  }\n\n  // Apply the update to all objects that match the given Parse Query.\n  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Atomically finds and updates an object based on query.\n  // Return value not currently well specified.\n  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.findAndModify(mongoWhere, [], mongoUpdate, { new: true }))\n      .then(result => mongoObjectToParseObject(className, result.value, schema))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Hopefully we can get rid of this. It's only used for config and hooks.\n  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.upsertOne(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.\n  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptions): Promise<any> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));\n    const mongoKeys = _.reduce(keys, (memo, key) => {\n      memo[transformKey(className, key, schema)] = 1;\n      return memo;\n    }, {});\n\n    readPreference = this._parseReadPreference(readPreference);\n    return this.createTextIndexesIfNeeded(className, query, schema)\n      .then(() => this._adaptiveCollection(className))\n      .then(collection => collection.find(mongoWhere, {\n        skip,\n        limit,\n        sort: mongoSort,\n        keys: mongoKeys,\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't\n  // currently know which fields are nullable and which aren't, we ignore that criteria.\n  // As such, we shouldn't expose this function to users of parse until we have an out-of-band\n  // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,\n  // which is why we use sparse indexes.\n  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const indexCreationRequest = {};\n    const mongoFieldNames = fieldNames.map(fieldName => transformKey(className, fieldName, schema));\n    mongoFieldNames.forEach(fieldName => {\n      indexCreationRequest[fieldName] = 1;\n    });\n    return this._adaptiveCollection(className)\n      .then(collection => collection._ensureSparseUniqueIndexInBackground(indexCreationRequest))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Tried to ensure field uniqueness for a class that already has duplicates.');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Used in tests\n  _rawFind(className: string, query: QueryType) {\n    return this._adaptiveCollection(className).then(collection => collection.find(query, {\n      maxTimeMS: this._maxTimeMS,\n    })).catch(err => this.handleError(err));\n  }\n\n  // Executes a count.\n  count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.count(transformWhere(className, query, schema), {\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const isPointerField = schema.fields[fieldName] && schema.fields[fieldName].type === 'Pointer';\n    if (isPointerField) {\n      fieldName = `_p_${fieldName}`\n    }\n    return this._adaptiveCollection(className)\n      .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)))\n      .then(objects => {\n        objects = objects.filter((obj) => obj != null);\n        return objects.map(object => {\n          if (isPointerField) {\n            const field = fieldName.substring(3);\n            return transformPointerString(schema, field, object);\n          }\n          return mongoObjectToParseObject(className, object, schema);\n        });\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) {\n    let isPointerField = false;\n    pipeline = pipeline.map((stage) => {\n      if (stage.$group) {\n        stage.$group = this._parseAggregateGroupArgs(schema, stage.$group);\n        if (stage.$group._id && (typeof stage.$group._id === 'string') && stage.$group._id.indexOf('$_p_') >= 0) {\n          isPointerField = true;\n        }\n      }\n      if (stage.$match) {\n        stage.$match = this._parseAggregateArgs(schema, stage.$match);\n      }\n      if (stage.$project) {\n        stage.$project = this._parseAggregateProjectArgs(schema, stage.$project);\n      }\n      return stage;\n    });\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS }))\n      .catch(error => {\n        if (error.code === 16006) {\n          throw new Parse.Error(Parse.Error.INVALID_QUERY, error.message);\n        }\n        throw error;\n      })\n      .then(results => {\n        results.forEach(result => {\n          if (result.hasOwnProperty('_id')) {\n            if (isPointerField && result._id) {\n              result._id = result._id.split('$')[1];\n            }\n            if (result._id == null || _.isEmpty(result._id)) {\n              result._id = null;\n            }\n            result.objectId = result._id;\n            delete result._id;\n          }\n        });\n        return results;\n      })\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // This function will recursively traverse the pipeline and convert any Pointer or Date columns.\n  // If we detect a pointer column we will rename the column being queried for to match the column\n  // in the database. We also modify the value to what we expect the value to be in the database\n  // as well.\n  // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert\n  // the string to a Date so the driver can perform the necessary comparison.\n  //\n  // The goal of this method is to look for the \"leaves\" of the pipeline and determine if it needs\n  // to be converted. The pipeline can have a few different forms. For more details, see:\n  //     https://docs.mongodb.com/manual/reference/operator/aggregation/\n  //\n  // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In\n  // that case we need to loop through all of it's children to find the columns being operated on.\n  // If the pipeline is an object, then we'll loop through the keys checking to see if the key name\n  // matches one of the schema columns. If it does match a column and the column is a Pointer or\n  // a Date, then we'll convert the value as described above.\n  //\n  // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing\n  // down a tree to find a \"leaf node\" and checking to see if it needs to be converted.\n  _parseAggregateArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n          if (typeof pipeline[field] === 'object') {\n            // Pass objects down to MongoDB...this is more than likely an $exists operator.\n            returnValue[`_p_${field}`] = pipeline[field];\n          } else {\n            returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`;\n          }\n        } else if (schema.fields[field] && schema.fields[field].type === 'Date') {\n          returnValue[field] = this._convertToDate(pipeline[field]);\n        } else {\n          returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n        }\n\n        if (field === 'objectId') {\n          returnValue['_id'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'createdAt') {\n          returnValue['_created_at'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'updatedAt') {\n          returnValue['_updated_at'] = returnValue[field];\n          delete returnValue[field];\n        }\n      }\n      return returnValue;\n    }\n    return pipeline;\n  }\n\n  // This function is slightly different than the one above. Rather than trying to combine these\n  // two functions and making the code even harder to understand, I decided to split it up. The\n  // difference with this function is we are not transforming the values, only the keys of the\n  // pipeline.\n  _parseAggregateProjectArgs(schema: any, pipeline: any): any {\n    const returnValue = {};\n    for (const field in pipeline) {\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        returnValue[`_p_${field}`] = pipeline[field];\n      } else {\n        returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n      }\n\n      if (field === 'objectId') {\n        returnValue['_id'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'createdAt') {\n        returnValue['_created_at'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'updatedAt') {\n        returnValue['_updated_at'] = returnValue[field];\n        delete returnValue[field];\n      }\n    }\n    return returnValue;\n  }\n\n  // This function is slightly different than the two above. MongoDB $group aggregate looks like:\n  //     { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }\n  // The <expression> could be a column name, prefixed with the '$' character. We'll look for\n  // these <expression> and check to see if it is a 'Pointer' or if it's one of createdAt,\n  // updatedAt or objectId and change it accordingly.\n  _parseAggregateGroupArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateGroupArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]);\n      }\n      return returnValue;\n    } else if (typeof pipeline === 'string') {\n      const field = pipeline.substring(1);\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        return `$_p_${field}`;\n      } else if (field == 'createdAt') {\n        return '$_created_at';\n      } else if (field == 'updatedAt') {\n        return '$_updated_at';\n      }\n    }\n    return pipeline;\n  }\n\n  // This function will attempt to convert the provided value to a Date object. Since this is part\n  // of an aggregation pipeline, the value can either be a string or it can be another object with\n  // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a\n  // recursive method to traverse down to the \"leaf node\" which is going to be the string.\n  _convertToDate(value: any): any {\n    if (typeof value === 'string') {\n      return new Date(value);\n    }\n\n    const returnValue = {}\n    for (const field in value) {\n      returnValue[field] = this._convertToDate(value[field])\n    }\n    return returnValue;\n  }\n\n  _parseReadPreference(readPreference: ?string): ?string {\n    switch (readPreference) {\n    case 'PRIMARY':\n      readPreference = ReadPreference.PRIMARY;\n      break;\n    case 'PRIMARY_PREFERRED':\n      readPreference = ReadPreference.PRIMARY_PREFERRED;\n      break;\n    case 'SECONDARY':\n      readPreference = ReadPreference.SECONDARY;\n      break;\n    case 'SECONDARY_PREFERRED':\n      readPreference = ReadPreference.SECONDARY_PREFERRED;\n      break;\n    case 'NEAREST':\n      readPreference = ReadPreference.NEAREST;\n      break;\n    case undefined:\n      break;\n    default:\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');\n    }\n    return readPreference;\n  }\n\n  performInitialization(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  createIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndex(index, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexes(className: string, indexes: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndexes(indexes, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexesIfNeeded(className: string, fieldName: string, type: any) {\n    if (type && type.type === 'Polygon') {\n      const index = {\n        [fieldName]: '2dsphere'\n      };\n      return this.createIndex(className, index);\n    }\n    return Promise.resolve();\n  }\n\n  createTextIndexesIfNeeded(className: string, query: QueryType, schema: any): Promise<void> {\n    for(const fieldName in query) {\n      if (!query[fieldName] || !query[fieldName].$text) {\n        continue;\n      }\n      const existingIndexes = schema.indexes;\n      for (const key in existingIndexes) {\n        const index = existingIndexes[key];\n        if (index.hasOwnProperty(fieldName)) {\n          return Promise.resolve();\n        }\n      }\n      const indexName = `${fieldName}_text`;\n      const textIndex = {\n        [indexName]: { [fieldName]: 'text' }\n      };\n      return this.setIndexesWithSchemaFormat(className, textIndex, existingIndexes, schema.fields)\n        .catch((error) => {\n          if (error.code === 85) { // Index exist with different options\n            return this.setIndexesFromMongo(className);\n          }\n          throw error;\n        });\n    }\n    return Promise.resolve();\n  }\n\n  getIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.indexes())\n      .catch(err => this.handleError(err));\n  }\n\n  dropIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndex(index))\n      .catch(err => this.handleError(err));\n  }\n\n  dropAllIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndexes())\n      .catch(err => this.handleError(err));\n  }\n\n  updateSchemaWithIndexes(): Promise<any> {\n    return this.getAllClasses()\n      .then((classes) => {\n        const promises = classes.map((schema) => {\n          return this.setIndexesFromMongo(schema.className);\n        });\n        return Promise.all(promises);\n      })\n      .catch(err => this.handleError(err));\n  }\n}\n\nexport default MongoStorageAdapter;\n"]} \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoTransform.js b/lib/Adapters/Storage/Mongo/MongoTransform.js index 0931dd48d8..f3e4261c03 100644 --- a/lib/Adapters/Storage/Mongo/MongoTransform.js +++ b/lib/Adapters/Storage/Mongo/MongoTransform.js @@ -141,6 +141,44 @@ const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSc return { key, value }; }; +const isRegex = value => { + return value && value instanceof RegExp; +}; + +const isStartsWithRegex = value => { + if (!isRegex(value)) { + return false; + } + + const matches = value.toString().match(/\/\^\\Q.*\\E\//); + return !!matches; +}; + +const isAllValuesRegexOrNone = values => { + if (!values || !Array.isArray(values) || values.length === 0) { + return true; + } + + const firstValuesIsRegex = isStartsWithRegex(values[0]); + if (values.length === 1) { + return firstValuesIsRegex; + } + + for (let i = 1, length = values.length; i < length; ++i) { + if (firstValuesIsRegex !== isStartsWithRegex(values[i])) { + return false; + } + } + + return true; +}; + +const isAnyValueRegex = values => { + return values.some(function (value) { + return isRegex(value); + }); +}; + const transformInteriorValue = restValue => { 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"); @@ -230,9 +268,9 @@ function transformQueryKeyValue(className, key, value, schema) { case '_email_verify_token': return { key, value }; case '$or': - return { key: '$or', value: value.map(subQuery => transformWhere(className, subQuery, schema)) }; case '$and': - return { key: '$and', value: value.map(subQuery => transformWhere(className, subQuery, schema)) }; + case '$nor': + return { key: key, value: value.map(subQuery => transformWhere(className, subQuery, schema)) }; case 'lastUsed': if (valueAsDate(value)) { return { key: '_last_used', value: valueAsDate(value) }; @@ -268,6 +306,9 @@ function transformQueryKeyValue(className, key, value, schema) { if (transformedConstraint.$text) { return { key: '$text', value: transformedConstraint.$text }; } + if (transformedConstraint.$elemMatch) { + return { key: '$nor', value: [{ [key]: transformedConstraint }] }; + } return { key, value: transformedConstraint }; } @@ -483,6 +524,8 @@ const transformInteriorAtom = atom => { return DateCoder.JSONToDatabase(atom); } else if (BytesCoder.isValidJSON(atom)) { return BytesCoder.JSONToDatabase(atom); + } else if (typeof atom === 'object' && atom && atom.$regex !== undefined) { + return new RegExp(atom.$regex); } else { return atom; } @@ -757,6 +800,12 @@ function transformConstraint(constraint, field) { throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value'); } answer[key] = arr.map(transformInteriorAtom); + + const values = answer[key]; + if (isAnyValueRegex(values) && !isAllValuesRegexOrNone(values)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'All $all values must be of regex type or none: ' + values); + } + break; } case '$regex': @@ -767,6 +816,17 @@ function transformConstraint(constraint, field) { answer[key] = s; break; + case '$containedBy': + { + const arr = constraint[key]; + if (!(arr instanceof Array)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $containedBy: should be an array`); + } + answer.$elemMatch = { + $nin: arr.map(transformer) + }; + break; + } case '$options': answer[key] = constraint[key]; break; @@ -839,23 +899,58 @@ function transformConstraint(constraint, field) { case '$geoWithin': { const polygon = constraint[key]['$polygon']; - if (!(polygon instanceof Array)) { - throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); - } - if (polygon.length < 3) { - throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); - } - const points = polygon.map(point => { - if (!GeoPointCoder.isValidJSON(point)) { - throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value'); + const centerSphere = constraint[key]['$centerSphere']; + if (polygon !== undefined) { + let points; + if (typeof polygon === 'object' && polygon.__type === 'Polygon') { + if (!polygon.coordinates || polygon.coordinates.length < 3) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs'); + } + points = polygon.coordinates; + } else if (polygon instanceof Array) { + if (polygon.length < 3) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + } + points = polygon; } else { - Parse.GeoPoint._validate(point.latitude, point.longitude); + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint\'s'); } - return [point.longitude, point.latitude]; - }); - answer[key] = { - '$polygon': points - }; + points = points.map(point => { + if (point instanceof Array && point.length === 2) { + Parse.GeoPoint._validate(point[1], point[0]); + return point; + } + if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value'); + } else { + Parse.GeoPoint._validate(point.latitude, point.longitude); + } + return [point.longitude, point.latitude]; + }); + answer[key] = { + '$polygon': points + }; + } else if (centerSphere !== undefined) { + if (!(centerSphere instanceof Array) || centerSphere.length < 2) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance'); + } + // Get point, convert to geo point if necessary and validate + let point = centerSphere[0]; + if (point instanceof Array && point.length === 2) { + point = new Parse.GeoPoint(point[1], point[0]); + } else if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid'); + } + Parse.GeoPoint._validate(point.latitude, point.longitude); + // Get distance and validate + const distance = centerSphere[1]; + if (isNaN(distance) || distance < 0) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid'); + } + answer[key] = { + '$centerSphere': [[point.longitude, point.latitude], distance] + }; + } break; } case '$geoIntersects': @@ -1325,4 +1420,5 @@ module.exports = { relativeTimeToDate, transformConstraint, transformPointerString -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoTransform.js"],"names":["mongodb","require","Parse","transformKey","className","fieldName","schema","fields","__type","type","transformKeyValueForUpdate","restKey","restValue","parseFormatSchema","key","timeField","value","parseInt","transformTopLevelAtom","CannotTransform","Date","indexOf","Array","map","transformInteriorValue","transformUpdateOperator","mapValues","isRegex","RegExp","isStartsWithRegex","matches","toString","match","isAllValuesRegexOrNone","values","isArray","length","firstValuesIsRegex","i","isAnyValueRegex","some","Object","keys","includes","Error","INVALID_NESTED_KEY","transformInteriorAtom","valueAsDate","transformQueryKeyValue","subQuery","transformWhere","authDataMatch","provider","expectedTypeIsArray","expectedTypeIsPointer","field","transformedConstraint","transformConstraint","$text","$elemMatch","INVALID_JSON","restWhere","mongoWhere","out","parseObjectKeyValueToMongoObjectKeyValue","transformedValue","coercedToDate","INVALID_KEY_NAME","parseObjectToMongoObjectForCreate","restCreate","addLegacyACL","mongoCreate","undefined","createdAt","_created_at","iso","updatedAt","_updated_at","transformUpdate","restUpdate","mongoUpdate","acl","_rperm","_wperm","_acl","$set","__op","arg","restObject","restObjectCopy","forEach","entry","w","r","atom","objectId","DateCoder","isValidJSON","JSONToDatabase","BytesCoder","$regex","targetClass","GeoPointCoder","PolygonCoder","FileCoder","INTERNAL_SERVER_ERROR","relativeTimeToDate","text","now","toLowerCase","parts","split","filter","part","future","past","status","info","slice","pairs","push","shift","seconds","num","interval","val","Number","isInteger","milliseconds","result","valueOf","constraint","inArray","transformFunction","transformer","JSON","stringify","sort","reverse","answer","$relativeTime","parserResult","log","arr","_","flatMap","s","$nin","search","$search","$term","$language","$caseSensitive","$diacriticSensitive","point","longitude","latitude","COMMAND_UNAVAILABLE","box","polygon","centerSphere","points","coordinates","GeoPoint","_validate","distance","isNaN","$geometry","amount","objects","flatten","toAdd","mongoOp","Add","AddUnique","toRemove","object","iterator","nestedMongoObjectToNestedParseObject","mongoObject","_encode","Long","toNumber","Double","isValidDatabaseObject","databaseToJSON","hasOwnProperty","toJSON","transformPointerString","pointerString","objData","mongoObjectToParseObject","_hashed_password","newKey","substring","relationFieldNames","relationFields","relationFieldName","json","base64Pattern","isBase64Value","test","buffer","base64","Binary","Buffer","coords","coord","parseFloat","unique","item","index","ar","foundIndex","pt","name","module","exports"],"mappings":"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","file":"MongoTransform.js","sourcesContent":["import log from '../../../logger';\nimport _   from 'lodash';\nvar mongodb = require('mongodb');\nvar Parse = require('parse/node').Parse;\n\nconst transformKey = (className, fieldName, schema) => {\n  // Check if the schema is known since it's a built-in field.\n  switch(fieldName) {\n  case 'objectId': return '_id';\n  case 'createdAt': return '_created_at';\n  case 'updatedAt': return '_updated_at';\n  case 'sessionToken': return '_session_token';\n  case 'lastUsed': return '_last_used';\n  case 'timesUsed': return 'times_used';\n  }\n\n  if (schema.fields[fieldName] && schema.fields[fieldName].__type == 'Pointer') {\n    fieldName = '_p_' + fieldName;\n  } else if (schema.fields[fieldName] && schema.fields[fieldName].type == 'Pointer') {\n    fieldName = '_p_' + fieldName;\n  }\n\n  return fieldName;\n}\n\nconst transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSchema) => {\n  // Check if the schema is known since it's a built-in field.\n  var key = restKey;\n  var timeField = false;\n  switch(key) {\n  case 'objectId':\n  case '_id':\n    if (className === '_GlobalConfig') {\n      return {\n        key: key,\n        value: parseInt(restValue)\n      }\n    }\n    key = '_id';\n    break;\n  case 'createdAt':\n  case '_created_at':\n    key = '_created_at';\n    timeField = true;\n    break;\n  case 'updatedAt':\n  case '_updated_at':\n    key = '_updated_at';\n    timeField = true;\n    break;\n  case 'sessionToken':\n  case '_session_token':\n    key = '_session_token';\n    break;\n  case 'expiresAt':\n  case '_expiresAt':\n    key = 'expiresAt';\n    timeField = true;\n    break;\n  case '_email_verify_token_expires_at':\n    key = '_email_verify_token_expires_at';\n    timeField = true;\n    break;\n  case '_account_lockout_expires_at':\n    key = '_account_lockout_expires_at';\n    timeField = true;\n    break;\n  case '_failed_login_count':\n    key = '_failed_login_count';\n    break;\n  case '_perishable_token_expires_at':\n    key = '_perishable_token_expires_at';\n    timeField = true;\n    break;\n  case '_password_changed_at':\n    key = '_password_changed_at';\n    timeField = true;\n    break;\n  case '_rperm':\n  case '_wperm':\n    return {key: key, value: restValue};\n  case 'lastUsed':\n  case '_last_used':\n    key = '_last_used';\n    timeField = true;\n    break;\n  case 'timesUsed':\n  case 'times_used':\n    key = 'times_used';\n    timeField = true;\n    break;\n  }\n\n  if ((parseFormatSchema.fields[key] && parseFormatSchema.fields[key].type === 'Pointer') || (!parseFormatSchema.fields[key] && restValue && restValue.__type == 'Pointer')) {\n    key = '_p_' + key;\n  }\n\n  // Handle atomic values\n  var value = transformTopLevelAtom(restValue);\n  if (value !== CannotTransform) {\n    if (timeField && (typeof value === 'string')) {\n      value = new Date(value);\n    }\n    if (restKey.indexOf('.') > 0) {\n      return {key, value: restValue}\n    }\n    return {key, value};\n  }\n\n  // Handle arrays\n  if (restValue instanceof Array) {\n    value = restValue.map(transformInteriorValue);\n    return {key, value};\n  }\n\n  // Handle update operators\n  if (typeof restValue === 'object' && '__op' in restValue) {\n    return {key, value: transformUpdateOperator(restValue, false)};\n  }\n\n  // Handle normal objects by recursing\n  value = mapValues(restValue, transformInteriorValue);\n  return {key, value};\n}\n\nconst isRegex = value => {\n  return value && (value instanceof RegExp)\n}\n\nconst isStartsWithRegex = value => {\n  if (!isRegex(value)) {\n    return false;\n  }\n\n  const matches = value.toString().match(/\\/\\^\\\\Q.*\\\\E\\//);\n  return !!matches;\n}\n\nconst isAllValuesRegexOrNone = values => {\n  if (!values || !Array.isArray(values) || values.length === 0) {\n    return true;\n  }\n\n  const firstValuesIsRegex = isStartsWithRegex(values[0]);\n  if (values.length === 1) {\n    return firstValuesIsRegex;\n  }\n\n  for (let i = 1, length = values.length; i < length; ++i) {\n    if (firstValuesIsRegex !== isStartsWithRegex(values[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nconst isAnyValueRegex = values => {\n  return values.some(function (value) {\n    return isRegex(value);\n  });\n}\n\nconst transformInteriorValue = restValue => {\n  if (restValue !== null && typeof restValue === 'object' && Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))) {\n    throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, \"Nested keys should not contain the '$' or '.' characters\");\n  }\n  // Handle atomic values\n  var value = transformInteriorAtom(restValue);\n  if (value !== CannotTransform) {\n    return value;\n  }\n\n  // Handle arrays\n  if (restValue instanceof Array) {\n    return restValue.map(transformInteriorValue);\n  }\n\n  // Handle update operators\n  if (typeof restValue === 'object' && '__op' in restValue) {\n    return transformUpdateOperator(restValue, true);\n  }\n\n  // Handle normal objects by recursing\n  return mapValues(restValue, transformInteriorValue);\n}\n\nconst valueAsDate = value => {\n  if (typeof value === 'string') {\n    return new Date(value);\n  } else if (value instanceof Date) {\n    return value;\n  }\n  return false;\n}\n\nfunction transformQueryKeyValue(className, key, value, schema) {\n  switch(key) {\n  case 'createdAt':\n    if (valueAsDate(value)) {\n      return {key: '_created_at', value: valueAsDate(value)}\n    }\n    key = '_created_at';\n    break;\n  case 'updatedAt':\n    if (valueAsDate(value)) {\n      return {key: '_updated_at', value: valueAsDate(value)}\n    }\n    key = '_updated_at';\n    break;\n  case 'expiresAt':\n    if (valueAsDate(value)) {\n      return {key: 'expiresAt', value: valueAsDate(value)}\n    }\n    break;\n  case '_email_verify_token_expires_at':\n    if (valueAsDate(value)) {\n      return {key: '_email_verify_token_expires_at', value: valueAsDate(value)}\n    }\n    break;\n  case 'objectId': {\n    if (className === '_GlobalConfig') {\n      value = parseInt(value);\n    }\n    return {key: '_id', value}\n  }\n  case '_account_lockout_expires_at':\n    if (valueAsDate(value)) {\n      return {key: '_account_lockout_expires_at', value: valueAsDate(value)}\n    }\n    break;\n  case '_failed_login_count':\n    return {key, value};\n  case 'sessionToken': return {key: '_session_token', value}\n  case '_perishable_token_expires_at':\n    if (valueAsDate(value)) {\n      return { key: '_perishable_token_expires_at', value: valueAsDate(value) }\n    }\n    break;\n  case '_password_changed_at':\n    if (valueAsDate(value)) {\n      return { key: '_password_changed_at', value: valueAsDate(value) }\n    }\n    break;\n  case '_rperm':\n  case '_wperm':\n  case '_perishable_token':\n  case '_email_verify_token': return {key, value}\n  case '$or':\n  case '$and':\n  case '$nor':\n    return {key: key, value: value.map(subQuery => transformWhere(className, subQuery, schema))};\n  case 'lastUsed':\n    if (valueAsDate(value)) {\n      return {key: '_last_used', value: valueAsDate(value)}\n    }\n    key = '_last_used';\n    break;\n  case 'timesUsed':\n    return {key: 'times_used', value: value};\n  default: {\n    // Other auth data\n    const authDataMatch = key.match(/^authData\\.([a-zA-Z0-9_]+)\\.id$/);\n    if (authDataMatch) {\n      const provider = authDataMatch[1];\n      // Special-case auth data.\n      return {key: `_auth_data_${provider}.id`, value};\n    }\n  }\n  }\n\n  const expectedTypeIsArray =\n    schema &&\n    schema.fields[key] &&\n    schema.fields[key].type === 'Array';\n\n  const expectedTypeIsPointer =\n    schema &&\n    schema.fields[key] &&\n    schema.fields[key].type === 'Pointer';\n\n  const field = schema && schema.fields[key];\n  if (expectedTypeIsPointer || !schema && value && value.__type === 'Pointer') {\n    key = '_p_' + key;\n  }\n\n  // Handle query constraints\n  const transformedConstraint = transformConstraint(value, field);\n  if (transformedConstraint !== CannotTransform) {\n    if (transformedConstraint.$text) {\n      return {key: '$text', value: transformedConstraint.$text};\n    }\n    if (transformedConstraint.$elemMatch) {\n      return { key: '$nor', value: [{ [key]: transformedConstraint }] };\n    }\n    return {key, value: transformedConstraint};\n  }\n\n  if (expectedTypeIsArray && !(value instanceof Array)) {\n    return {key, value: { '$all' : [transformInteriorAtom(value)] }};\n  }\n\n  // Handle atomic values\n  if (transformTopLevelAtom(value) !== CannotTransform) {\n    return {key, value: transformTopLevelAtom(value)};\n  } else {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, `You cannot use ${value} as a query parameter.`);\n  }\n}\n\n// Main exposed method to help run queries.\n// restWhere is the \"where\" clause in REST API form.\n// Returns the mongo form of the query.\nfunction transformWhere(className, restWhere, schema) {\n  const mongoWhere = {};\n  for (const restKey in restWhere) {\n    const out = transformQueryKeyValue(className, restKey, restWhere[restKey], schema);\n    mongoWhere[out.key] = out.value;\n  }\n  return mongoWhere;\n}\n\nconst parseObjectKeyValueToMongoObjectKeyValue = (restKey, restValue, schema) => {\n  // Check if the schema is known since it's a built-in field.\n  let transformedValue;\n  let coercedToDate;\n  switch(restKey) {\n  case 'objectId': return {key: '_id', value: restValue};\n  case 'expiresAt':\n    transformedValue = transformTopLevelAtom(restValue);\n    coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue\n    return {key: 'expiresAt', value: coercedToDate};\n  case '_email_verify_token_expires_at':\n    transformedValue = transformTopLevelAtom(restValue);\n    coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue\n    return {key: '_email_verify_token_expires_at', value: coercedToDate};\n  case '_account_lockout_expires_at':\n    transformedValue = transformTopLevelAtom(restValue);\n    coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue\n    return {key: '_account_lockout_expires_at', value: coercedToDate};\n  case '_perishable_token_expires_at':\n    transformedValue = transformTopLevelAtom(restValue);\n    coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue\n    return { key: '_perishable_token_expires_at', value: coercedToDate };\n  case '_password_changed_at':\n    transformedValue = transformTopLevelAtom(restValue);\n    coercedToDate = typeof transformedValue === 'string' ? new Date(transformedValue) : transformedValue\n    return { key: '_password_changed_at', value: coercedToDate };\n  case '_failed_login_count':\n  case '_rperm':\n  case '_wperm':\n  case '_email_verify_token':\n  case '_hashed_password':\n  case '_perishable_token': return {key: restKey, value: restValue};\n  case 'sessionToken': return {key: '_session_token', value: restValue};\n  default:\n    // Auth data should have been transformed already\n    if (restKey.match(/^authData\\.([a-zA-Z0-9_]+)\\.id$/)) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'can only query on ' + restKey);\n    }\n    // Trust that the auth data has been transformed and save it directly\n    if (restKey.match(/^_auth_data_[a-zA-Z0-9_]+$/)) {\n      return {key: restKey, value: restValue};\n    }\n  }\n  //skip straight to transformTopLevelAtom for Bytes, they don't show up in the schema for some reason\n  if (restValue && restValue.__type !== 'Bytes') {\n    //Note: We may not know the type of a field here, as the user could be saving (null) to a field\n    //That never existed before, meaning we can't infer the type.\n    if (schema.fields[restKey] && schema.fields[restKey].type == 'Pointer' || restValue.__type == 'Pointer') {\n      restKey = '_p_' + restKey;\n    }\n  }\n\n  // Handle atomic values\n  var value = transformTopLevelAtom(restValue);\n  if (value !== CannotTransform) {\n    return {key: restKey, value: value};\n  }\n\n  // ACLs are handled before this method is called\n  // If an ACL key still exists here, something is wrong.\n  if (restKey === 'ACL') {\n    throw 'There was a problem transforming an ACL.';\n  }\n\n  // Handle arrays\n  if (restValue instanceof Array) {\n    value = restValue.map(transformInteriorValue);\n    return {key: restKey, value: value};\n  }\n\n  // Handle normal objects by recursing\n  if (Object.keys(restValue).some(key => key.includes('$') || key.includes('.'))) {\n    throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, \"Nested keys should not contain the '$' or '.' characters\");\n  }\n  value = mapValues(restValue, transformInteriorValue);\n  return {key: restKey, value};\n}\n\nconst parseObjectToMongoObjectForCreate = (className, restCreate, schema) => {\n  restCreate = addLegacyACL(restCreate);\n  const mongoCreate = {}\n  for (const restKey in restCreate) {\n    if (restCreate[restKey] && restCreate[restKey].__type === 'Relation') {\n      continue;\n    }\n    const { key, value } = parseObjectKeyValueToMongoObjectKeyValue(\n      restKey,\n      restCreate[restKey],\n      schema\n    );\n    if (value !== undefined) {\n      mongoCreate[key] = value;\n    }\n  }\n\n  // Use the legacy mongo format for createdAt and updatedAt\n  if (mongoCreate.createdAt) {\n    mongoCreate._created_at = new Date(mongoCreate.createdAt.iso || mongoCreate.createdAt);\n    delete mongoCreate.createdAt;\n  }\n  if (mongoCreate.updatedAt) {\n    mongoCreate._updated_at = new Date(mongoCreate.updatedAt.iso || mongoCreate.updatedAt);\n    delete mongoCreate.updatedAt;\n  }\n\n  return mongoCreate;\n}\n\n// Main exposed method to help update old objects.\nconst transformUpdate = (className, restUpdate, parseFormatSchema) => {\n  const mongoUpdate = {};\n  const acl = addLegacyACL(restUpdate);\n  if (acl._rperm || acl._wperm || acl._acl) {\n    mongoUpdate.$set = {};\n    if (acl._rperm) {\n      mongoUpdate.$set._rperm = acl._rperm;\n    }\n    if (acl._wperm) {\n      mongoUpdate.$set._wperm = acl._wperm;\n    }\n    if (acl._acl) {\n      mongoUpdate.$set._acl = acl._acl;\n    }\n  }\n  for (var restKey in restUpdate) {\n    if (restUpdate[restKey] && restUpdate[restKey].__type === 'Relation') {\n      continue;\n    }\n    var out = transformKeyValueForUpdate(className, restKey, restUpdate[restKey], parseFormatSchema);\n\n    // If the output value is an object with any $ keys, it's an\n    // operator that needs to be lifted onto the top level update\n    // object.\n    if (typeof out.value === 'object' && out.value !== null && out.value.__op) {\n      mongoUpdate[out.value.__op] = mongoUpdate[out.value.__op] || {};\n      mongoUpdate[out.value.__op][out.key] = out.value.arg;\n    } else {\n      mongoUpdate['$set'] = mongoUpdate['$set'] || {};\n      mongoUpdate['$set'][out.key] = out.value;\n    }\n  }\n\n  return mongoUpdate;\n}\n\n// Add the legacy _acl format.\nconst addLegacyACL = restObject => {\n  const restObjectCopy = {...restObject};\n  const _acl = {};\n\n  if (restObject._wperm) {\n    restObject._wperm.forEach(entry => {\n      _acl[entry] = { w: true };\n    });\n    restObjectCopy._acl = _acl;\n  }\n\n  if (restObject._rperm) {\n    restObject._rperm.forEach(entry => {\n      if (!(entry in _acl)) {\n        _acl[entry] = { r: true };\n      } else {\n        _acl[entry].r = true;\n      }\n    });\n    restObjectCopy._acl = _acl;\n  }\n\n  return restObjectCopy;\n}\n\n\n// A sentinel value that helper transformations return when they\n// cannot perform a transformation\nfunction CannotTransform() {}\n\nconst transformInteriorAtom = (atom) => {\n  // TODO: check validity harder for the __type-defined types\n  if (typeof atom === 'object' && atom && !(atom instanceof Date) && atom.__type === 'Pointer') {\n    return {\n      __type: 'Pointer',\n      className: atom.className,\n      objectId: atom.objectId\n    };\n  } else if (typeof atom === 'function' || typeof atom === 'symbol') {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`);\n  } else if (DateCoder.isValidJSON(atom)) {\n    return DateCoder.JSONToDatabase(atom);\n  } else if (BytesCoder.isValidJSON(atom)) {\n    return BytesCoder.JSONToDatabase(atom);\n  } else if (typeof atom === 'object' && atom && atom.$regex !== undefined) {\n    return new RegExp(atom.$regex);\n  } else {\n    return atom;\n  }\n}\n\n// Helper function to transform an atom from REST format to Mongo format.\n// An atom is anything that can't contain other expressions. So it\n// includes things where objects are used to represent other\n// datatypes, like pointers and dates, but it does not include objects\n// or arrays with generic stuff inside.\n// Raises an error if this cannot possibly be valid REST format.\n// Returns CannotTransform if it's just not an atom\nfunction transformTopLevelAtom(atom, field) {\n  switch(typeof atom) {\n  case 'number':\n  case 'boolean':\n  case 'undefined':\n    return atom;\n  case 'string':\n    if (field && field.type === 'Pointer') {\n      return `${field.targetClass}$${atom}`;\n    }\n    return atom;\n  case 'symbol':\n  case 'function':\n    throw new Parse.Error(Parse.Error.INVALID_JSON, `cannot transform value: ${atom}`);\n  case 'object':\n    if (atom instanceof Date) {\n      // Technically dates are not rest format, but, it seems pretty\n      // clear what they should be transformed to, so let's just do it.\n      return atom;\n    }\n\n    if (atom === null) {\n      return atom;\n    }\n\n    // TODO: check validity harder for the __type-defined types\n    if (atom.__type == 'Pointer') {\n      return `${atom.className}$${atom.objectId}`;\n    }\n    if (DateCoder.isValidJSON(atom)) {\n      return DateCoder.JSONToDatabase(atom);\n    }\n    if (BytesCoder.isValidJSON(atom)) {\n      return BytesCoder.JSONToDatabase(atom);\n    }\n    if (GeoPointCoder.isValidJSON(atom)) {\n      return GeoPointCoder.JSONToDatabase(atom);\n    }\n    if (PolygonCoder.isValidJSON(atom)) {\n      return PolygonCoder.JSONToDatabase(atom);\n    }\n    if (FileCoder.isValidJSON(atom)) {\n      return FileCoder.JSONToDatabase(atom);\n    }\n    return CannotTransform;\n\n  default:\n    // I don't think typeof can ever let us get here\n    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, `really did not expect value: ${atom}`);\n  }\n}\n\nfunction relativeTimeToDate(text, now = new Date()) {\n  text = text.toLowerCase();\n\n  let parts = text.split(' ');\n\n  // Filter out whitespace\n  parts = parts.filter((part) => part !== '');\n\n  const future = parts[0] === 'in';\n  const past = parts[parts.length - 1] === 'ago';\n\n  if (!future && !past && text !== 'now') {\n    return { status: 'error', info: \"Time should either start with 'in' or end with 'ago'\" };\n  }\n\n  if (future && past) {\n    return {\n      status: 'error',\n      info: \"Time cannot have both 'in' and 'ago'\",\n    };\n  }\n\n  // strip the 'ago' or 'in'\n  if (future) {\n    parts = parts.slice(1);\n  } else { // past\n    parts = parts.slice(0, parts.length - 1);\n  }\n\n  if (parts.length % 2 !== 0 && text !== 'now') {\n    return {\n      status: 'error',\n      info: 'Invalid time string. Dangling unit or number.',\n    };\n  }\n\n  const pairs = [];\n  while(parts.length) {\n    pairs.push([ parts.shift(), parts.shift() ]);\n  }\n\n  let seconds = 0;\n  for (const [num, interval] of pairs) {\n    const val = Number(num);\n    if (!Number.isInteger(val)) {\n      return {\n        status: 'error',\n        info: `'${num}' is not an integer.`,\n      };\n    }\n\n    switch(interval) {\n    case 'yr':\n    case 'yrs':\n    case 'year':\n    case 'years':\n      seconds += val * 31536000; // 365 * 24 * 60 * 60\n      break;\n\n    case 'wk':\n    case 'wks':\n    case 'week':\n    case 'weeks':\n      seconds += val * 604800; // 7 * 24 * 60 * 60\n      break;\n\n    case 'd':\n    case 'day':\n    case 'days':\n      seconds += val * 86400; // 24 * 60 * 60\n      break;\n\n    case 'hr':\n    case 'hrs':\n    case 'hour':\n    case 'hours':\n      seconds += val * 3600; // 60 * 60\n      break;\n\n    case 'min':\n    case 'mins':\n    case 'minute':\n    case 'minutes':\n      seconds += val * 60;\n      break;\n\n    case 'sec':\n    case 'secs':\n    case 'second':\n    case 'seconds':\n      seconds += val;\n      break;\n\n    default:\n      return {\n        status: 'error',\n        info: `Invalid interval: '${interval}'`,\n      };\n    }\n  }\n\n  const milliseconds = seconds * 1000;\n  if (future) {\n    return {\n      status: 'success',\n      info: 'future',\n      result: new Date(now.valueOf() + milliseconds)\n    };\n  } else if (past) {\n    return {\n      status: 'success',\n      info: 'past',\n      result: new Date(now.valueOf() - milliseconds)\n    };\n  } else {\n    return {\n      status: 'success',\n      info: 'present',\n      result: new Date(now.valueOf())\n    }\n  }\n}\n\n// Transforms a query constraint from REST API format to Mongo format.\n// A constraint is something with fields like $lt.\n// If it is not a valid constraint but it could be a valid something\n// else, return CannotTransform.\n// inArray is whether this is an array field.\nfunction transformConstraint(constraint, field) {\n  const inArray = field && field.type && field.type === 'Array';\n  if (typeof constraint !== 'object' || !constraint) {\n    return CannotTransform;\n  }\n  const transformFunction = inArray ? transformInteriorAtom : transformTopLevelAtom;\n  const transformer = (atom) => {\n    const result = transformFunction(atom, field);\n    if (result === CannotTransform) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, `bad atom: ${JSON.stringify(atom)}`);\n    }\n    return result;\n  }\n  // keys is the constraints in reverse alphabetical order.\n  // This is a hack so that:\n  //   $regex is handled before $options\n  //   $nearSphere is handled before $maxDistance\n  var keys = Object.keys(constraint).sort().reverse();\n  var answer = {};\n  for (var key of keys) {\n    switch(key) {\n    case '$lt':\n    case '$lte':\n    case '$gt':\n    case '$gte':\n    case '$exists':\n    case '$ne':\n    case '$eq': {\n      const val = constraint[key];\n      if (val && typeof val === 'object' && val.$relativeTime) {\n        if (field && field.type !== 'Date') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, '$relativeTime can only be used with Date field');\n        }\n\n        switch (key) {\n        case '$exists':\n        case '$ne':\n        case '$eq':\n          throw new Parse.Error(Parse.Error.INVALID_JSON, '$relativeTime can only be used with the $lt, $lte, $gt, and $gte operators');\n        }\n\n        const parserResult = relativeTimeToDate(val.$relativeTime);\n        if (parserResult.status === 'success') {\n          answer[key] = parserResult.result;\n          break;\n        }\n\n        log.info('Error while parsing relative date', parserResult);\n        throw new Parse.Error(Parse.Error.INVALID_JSON, `bad $relativeTime (${key}) value. ${parserResult.info}`);\n      }\n\n      answer[key] = transformer(val);\n      break;\n    }\n\n    case '$in':\n    case '$nin': {\n      const arr = constraint[key];\n      if (!(arr instanceof Array)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad ' + key + ' value');\n      }\n      answer[key] = _.flatMap(arr, value => {\n        return ((atom) => {\n          if (Array.isArray(atom)) {\n            return value.map(transformer);\n          } else {\n            return transformer(atom);\n          }\n        })(value);\n      });\n      break;\n    }\n    case '$all': {\n      const arr = constraint[key];\n      if (!(arr instanceof Array)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON,\n          'bad ' + key + ' value');\n      }\n      answer[key] = arr.map(transformInteriorAtom);\n\n      const values = answer[key];\n      if (isAnyValueRegex(values) && !isAllValuesRegexOrNone(values)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'All $all values must be of regex type or none: '\n          + values);\n      }\n\n      break;\n    }\n    case '$regex':\n      var s = constraint[key];\n      if (typeof s !== 'string') {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad regex: ' + s);\n      }\n      answer[key] = s;\n      break;\n\n    case '$containedBy': {\n      const arr = constraint[key];\n      if (!(arr instanceof Array)) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $containedBy: should be an array`\n        );\n      }\n      answer.$elemMatch = {\n        $nin: arr.map(transformer)\n      };\n      break;\n    }\n    case '$options':\n      answer[key] = constraint[key];\n      break;\n\n    case '$text': {\n      const search = constraint[key].$search;\n      if (typeof search !== 'object') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $search, should be object`\n        );\n      }\n      if (!search.$term || typeof search.$term !== 'string') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $term, should be string`\n        );\n      } else {\n        answer[key] = {\n          '$search': search.$term\n        }\n      }\n      if (search.$language && typeof search.$language !== 'string') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $language, should be string`\n        );\n      } else if (search.$language) {\n        answer[key].$language = search.$language;\n      }\n      if (search.$caseSensitive && typeof search.$caseSensitive !== 'boolean') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $caseSensitive, should be boolean`\n        );\n      } else if (search.$caseSensitive) {\n        answer[key].$caseSensitive = search.$caseSensitive;\n      }\n      if (search.$diacriticSensitive && typeof search.$diacriticSensitive !== 'boolean') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $diacriticSensitive, should be boolean`\n        );\n      } else if (search.$diacriticSensitive) {\n        answer[key].$diacriticSensitive = search.$diacriticSensitive;\n      }\n      break;\n    }\n    case '$nearSphere':\n      var point = constraint[key];\n      answer[key] = [point.longitude, point.latitude];\n      break;\n\n    case '$maxDistance':\n      answer[key] = constraint[key];\n      break;\n\n    // The SDKs don't seem to use these but they are documented in the\n    // REST API docs.\n    case '$maxDistanceInRadians':\n      answer['$maxDistance'] = constraint[key];\n      break;\n    case '$maxDistanceInMiles':\n      answer['$maxDistance'] = constraint[key] / 3959;\n      break;\n    case '$maxDistanceInKilometers':\n      answer['$maxDistance'] = constraint[key] / 6371;\n      break;\n\n    case '$select':\n    case '$dontSelect':\n      throw new Parse.Error(\n        Parse.Error.COMMAND_UNAVAILABLE,\n        'the ' + key + ' constraint is not supported yet');\n\n    case '$within':\n      var box = constraint[key]['$box'];\n      if (!box || box.length != 2) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          'malformatted $within arg');\n      }\n      answer[key] = {\n        '$box': [\n          [box[0].longitude, box[0].latitude],\n          [box[1].longitude, box[1].latitude]\n        ]\n      };\n      break;\n\n    case '$geoWithin': {\n      const polygon = constraint[key]['$polygon'];\n      const centerSphere = constraint[key]['$centerSphere'];\n      if (polygon !== undefined) {\n        let points;\n        if (typeof polygon === 'object' && polygon.__type === 'Polygon') {\n          if (!polygon.coordinates || polygon.coordinates.length < 3) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs'\n            );\n          }\n          points = polygon.coordinates;\n        } else if (polygon instanceof Array) {\n          if (polygon.length < 3) {\n            throw new Parse.Error(\n              Parse.Error.INVALID_JSON,\n              'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'\n            );\n          }\n          points = polygon;\n        } else {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            'bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint\\'s'\n          );\n        }\n        points = points.map((point) => {\n          if (point instanceof Array && point.length === 2) {\n            Parse.GeoPoint._validate(point[1], point[0]);\n            return point;\n          }\n          if (!GeoPointCoder.isValidJSON(point)) {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value');\n          } else {\n            Parse.GeoPoint._validate(point.latitude, point.longitude);\n          }\n          return [point.longitude, point.latitude];\n        });\n        answer[key] = {\n          '$polygon': points\n        };\n      } else if (centerSphere !== undefined) {\n        if (!(centerSphere instanceof Array) || centerSphere.length < 2) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance');\n        }\n        // Get point, convert to geo point if necessary and validate\n        let point = centerSphere[0];\n        if (point instanceof Array && point.length === 2) {\n          point = new Parse.GeoPoint(point[1], point[0]);\n        } else if (!GeoPointCoder.isValidJSON(point)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid');\n        }\n        Parse.GeoPoint._validate(point.latitude, point.longitude);\n        // Get distance and validate\n        const distance = centerSphere[1];\n        if(isNaN(distance) || distance < 0) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid');\n        }\n        answer[key] = {\n          '$centerSphere': [\n            [point.longitude, point.latitude],\n            distance\n          ]\n        };\n      }\n      break;\n    }\n    case '$geoIntersects': {\n      const point = constraint[key]['$point'];\n      if (!GeoPointCoder.isValidJSON(point)) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          'bad $geoIntersect value; $point should be GeoPoint'\n        );\n      } else {\n        Parse.GeoPoint._validate(point.latitude, point.longitude);\n      }\n      answer[key] = {\n        $geometry: {\n          type: 'Point',\n          coordinates: [point.longitude, point.latitude]\n        }\n      };\n      break;\n    }\n    default:\n      if (key.match(/^\\$+/)) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          'bad constraint: ' + key);\n      }\n      return CannotTransform;\n    }\n  }\n  return answer;\n}\n\n// Transforms an update operator from REST format to mongo format.\n// To be transformed, the input should have an __op field.\n// If flatten is true, this will flatten operators to their static\n// data format. For example, an increment of 2 would simply become a\n// 2.\n// The output for a non-flattened operator is a hash with __op being\n// the mongo op, and arg being the argument.\n// The output for a flattened operator is just a value.\n// Returns undefined if this should be a no-op.\n\nfunction transformUpdateOperator({\n  __op,\n  amount,\n  objects,\n}, flatten) {\n  switch(__op) {\n  case 'Delete':\n    if (flatten) {\n      return undefined;\n    } else {\n      return {__op: '$unset', arg: ''};\n    }\n\n  case 'Increment':\n    if (typeof amount !== 'number') {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'incrementing must provide a number');\n    }\n    if (flatten) {\n      return amount;\n    } else {\n      return {__op: '$inc', arg: amount};\n    }\n\n  case 'Add':\n  case 'AddUnique':\n    if (!(objects instanceof Array)) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n    }\n    var toAdd = objects.map(transformInteriorAtom);\n    if (flatten) {\n      return toAdd;\n    } else {\n      var mongoOp = {\n        Add: '$push',\n        AddUnique: '$addToSet'\n      }[__op];\n      return {__op: mongoOp, arg: {'$each': toAdd}};\n    }\n\n  case 'Remove':\n    if (!(objects instanceof Array)) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to remove must be an array');\n    }\n    var toRemove = objects.map(transformInteriorAtom);\n    if (flatten) {\n      return [];\n    } else {\n      return {__op: '$pullAll', arg: toRemove};\n    }\n\n  default:\n    throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, `The ${__op} operator is not supported yet.`);\n  }\n}\nfunction mapValues(object, iterator) {\n  const result = {};\n  Object.keys(object).forEach((key) => {\n    result[key] = iterator(object[key]);\n  });\n  return result;\n}\n\nconst nestedMongoObjectToNestedParseObject = mongoObject => {\n  switch(typeof mongoObject) {\n  case 'string':\n  case 'number':\n  case 'boolean':\n    return mongoObject;\n  case 'undefined':\n  case 'symbol':\n  case 'function':\n    throw 'bad value in mongoObjectToParseObject';\n  case 'object':\n    if (mongoObject === null) {\n      return null;\n    }\n    if (mongoObject instanceof Array) {\n      return mongoObject.map(nestedMongoObjectToNestedParseObject);\n    }\n\n    if (mongoObject instanceof Date) {\n      return Parse._encode(mongoObject);\n    }\n\n    if (mongoObject instanceof mongodb.Long) {\n      return mongoObject.toNumber();\n    }\n\n    if (mongoObject instanceof mongodb.Double) {\n      return mongoObject.value;\n    }\n\n    if (BytesCoder.isValidDatabaseObject(mongoObject)) {\n      return BytesCoder.databaseToJSON(mongoObject);\n    }\n\n    if (mongoObject.hasOwnProperty('__type') && mongoObject.__type == 'Date' && mongoObject.iso instanceof Date) {\n      mongoObject.iso = mongoObject.iso.toJSON();\n      return mongoObject;\n    }\n\n    return mapValues(mongoObject, nestedMongoObjectToNestedParseObject);\n  default:\n    throw 'unknown js type';\n  }\n}\n\nconst transformPointerString = (schema, field, pointerString) => {\n  const objData = pointerString.split('$');\n  if (objData[0] !== schema.fields[field].targetClass) {\n    throw 'pointer to incorrect className';\n  }\n  return {\n    __type: 'Pointer',\n    className: objData[0],\n    objectId: objData[1]\n  };\n}\n\n// Converts from a mongo-format object to a REST-format object.\n// Does not strip out anything based on a lack of authentication.\nconst mongoObjectToParseObject = (className, mongoObject, schema) => {\n  switch(typeof mongoObject) {\n  case 'string':\n  case 'number':\n  case 'boolean':\n    return mongoObject;\n  case 'undefined':\n  case 'symbol':\n  case 'function':\n    throw 'bad value in mongoObjectToParseObject';\n  case 'object': {\n    if (mongoObject === null) {\n      return null;\n    }\n    if (mongoObject instanceof Array) {\n      return mongoObject.map(nestedMongoObjectToNestedParseObject);\n    }\n\n    if (mongoObject instanceof Date) {\n      return Parse._encode(mongoObject);\n    }\n\n    if (mongoObject instanceof mongodb.Long) {\n      return mongoObject.toNumber();\n    }\n\n    if (mongoObject instanceof mongodb.Double) {\n      return mongoObject.value;\n    }\n\n    if (BytesCoder.isValidDatabaseObject(mongoObject)) {\n      return BytesCoder.databaseToJSON(mongoObject);\n    }\n\n    const restObject = {};\n    if (mongoObject._rperm || mongoObject._wperm) {\n      restObject._rperm = mongoObject._rperm || [];\n      restObject._wperm = mongoObject._wperm || [];\n      delete mongoObject._rperm;\n      delete mongoObject._wperm;\n    }\n\n    for (var key in mongoObject) {\n      switch(key) {\n      case '_id':\n        restObject['objectId'] = '' + mongoObject[key];\n        break;\n      case '_hashed_password':\n        restObject._hashed_password = mongoObject[key];\n        break;\n      case '_acl':\n        break;\n      case '_email_verify_token':\n      case '_perishable_token':\n      case '_perishable_token_expires_at':\n      case '_password_changed_at':\n      case '_tombstone':\n      case '_email_verify_token_expires_at':\n      case '_account_lockout_expires_at':\n      case '_failed_login_count':\n      case '_password_history':\n        // Those keys will be deleted if needed in the DB Controller\n        restObject[key] = mongoObject[key];\n        break;\n      case '_session_token':\n        restObject['sessionToken'] = mongoObject[key];\n        break;\n      case 'updatedAt':\n      case '_updated_at':\n        restObject['updatedAt'] = Parse._encode(new Date(mongoObject[key])).iso;\n        break;\n      case 'createdAt':\n      case '_created_at':\n        restObject['createdAt'] = Parse._encode(new Date(mongoObject[key])).iso;\n        break;\n      case 'expiresAt':\n      case '_expiresAt':\n        restObject['expiresAt'] = Parse._encode(new Date(mongoObject[key]));\n        break;\n      case 'lastUsed':\n      case '_last_used':\n        restObject['lastUsed'] = Parse._encode(new Date(mongoObject[key])).iso;\n        break;\n      case 'timesUsed':\n      case 'times_used':\n        restObject['timesUsed'] = mongoObject[key];\n        break;\n      default:\n        // Check other auth data keys\n        var authDataMatch = key.match(/^_auth_data_([a-zA-Z0-9_]+)$/);\n        if (authDataMatch) {\n          var provider = authDataMatch[1];\n          restObject['authData'] = restObject['authData'] || {};\n          restObject['authData'][provider] = mongoObject[key];\n          break;\n        }\n\n        if (key.indexOf('_p_') == 0) {\n          var newKey = key.substring(3);\n          if (!schema.fields[newKey]) {\n            log.info('transform.js', 'Found a pointer column not in the schema, dropping it.', className, newKey);\n            break;\n          }\n          if (schema.fields[newKey].type !== 'Pointer') {\n            log.info('transform.js', 'Found a pointer in a non-pointer column, dropping it.', className, key);\n            break;\n          }\n          if (mongoObject[key] === null) {\n            break;\n          }\n          restObject[newKey] = transformPointerString(schema, newKey, mongoObject[key]);\n          break;\n        } else if (key[0] == '_' && key != '__type') {\n          throw ('bad key in untransform: ' + key);\n        } else {\n          var value = mongoObject[key];\n          if (schema.fields[key] && schema.fields[key].type === 'File' && FileCoder.isValidDatabaseObject(value)) {\n            restObject[key] = FileCoder.databaseToJSON(value);\n            break;\n          }\n          if (schema.fields[key] && schema.fields[key].type === 'GeoPoint' && GeoPointCoder.isValidDatabaseObject(value)) {\n            restObject[key] = GeoPointCoder.databaseToJSON(value);\n            break;\n          }\n          if (schema.fields[key] && schema.fields[key].type === 'Polygon' && PolygonCoder.isValidDatabaseObject(value)) {\n            restObject[key] = PolygonCoder.databaseToJSON(value);\n            break;\n          }\n          if (schema.fields[key] && schema.fields[key].type === 'Bytes' && BytesCoder.isValidDatabaseObject(value)) {\n            restObject[key] = BytesCoder.databaseToJSON(value);\n            break;\n          }\n        }\n        restObject[key] = nestedMongoObjectToNestedParseObject(mongoObject[key]);\n      }\n    }\n\n    const relationFieldNames = Object.keys(schema.fields).filter(fieldName => schema.fields[fieldName].type === 'Relation');\n    const relationFields = {};\n    relationFieldNames.forEach(relationFieldName => {\n      relationFields[relationFieldName] = {\n        __type: 'Relation',\n        className: schema.fields[relationFieldName].targetClass,\n      }\n    });\n\n    return { ...restObject, ...relationFields };\n  }\n  default:\n    throw 'unknown js type';\n  }\n}\n\nvar DateCoder = {\n  JSONToDatabase(json) {\n    return new Date(json.iso);\n  },\n\n  isValidJSON(value) {\n    return (typeof value === 'object' &&\n      value !== null &&\n      value.__type === 'Date'\n    );\n  }\n};\n\nvar BytesCoder = {\n  base64Pattern: new RegExp(\"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$\"),\n  isBase64Value(object) {\n    if (typeof object !== 'string') {\n      return false;\n    }\n    return this.base64Pattern.test(object);\n  },\n\n  databaseToJSON(object) {\n    let value;\n    if (this.isBase64Value(object)) {\n      value = object;\n    } else {\n      value = object.buffer.toString('base64');\n    }\n    return {\n      __type: 'Bytes',\n      base64: value\n    };\n  },\n\n  isValidDatabaseObject(object) {\n    return (object instanceof mongodb.Binary) || this.isBase64Value(object);\n  },\n\n  JSONToDatabase(json) {\n    return new mongodb.Binary(new Buffer(json.base64, 'base64'));\n  },\n\n  isValidJSON(value) {\n    return (typeof value === 'object' &&\n      value !== null &&\n      value.__type === 'Bytes'\n    );\n  }\n};\n\nvar GeoPointCoder = {\n  databaseToJSON(object) {\n    return {\n      __type: 'GeoPoint',\n      latitude: object[1],\n      longitude: object[0]\n    }\n  },\n\n  isValidDatabaseObject(object) {\n    return (object instanceof Array &&\n      object.length == 2\n    );\n  },\n\n  JSONToDatabase(json) {\n    return [ json.longitude, json.latitude ];\n  },\n\n  isValidJSON(value) {\n    return (typeof value === 'object' &&\n      value !== null &&\n      value.__type === 'GeoPoint'\n    );\n  }\n};\n\nvar PolygonCoder = {\n  databaseToJSON(object) {\n    // Convert lng/lat -> lat/lng\n    const coords = object.coordinates[0].map((coord) => {\n      return [coord[1], coord[0]];\n    });\n    return {\n      __type: 'Polygon',\n      coordinates: coords\n    }\n  },\n\n  isValidDatabaseObject(object) {\n    const coords = object.coordinates[0];\n    if (object.type !== 'Polygon' || !(coords instanceof Array)) {\n      return false;\n    }\n    for (let i = 0; i < coords.length; i++) {\n      const point = coords[i];\n      if (!GeoPointCoder.isValidDatabaseObject(point)) {\n        return false;\n      }\n      Parse.GeoPoint._validate(parseFloat(point[1]), parseFloat(point[0]));\n    }\n    return true;\n  },\n\n  JSONToDatabase(json) {\n    let coords = json.coordinates;\n    // Add first point to the end to close polygon\n    if (coords[0][0] !== coords[coords.length - 1][0] ||\n        coords[0][1] !== coords[coords.length - 1][1]) {\n      coords.push(coords[0]);\n    }\n    const unique = coords.filter((item, index, ar) => {\n      let foundIndex = -1;\n      for (let i = 0; i < ar.length; i += 1) {\n        const pt = ar[i];\n        if (pt[0] === item[0] &&\n            pt[1] === item[1]) {\n          foundIndex = i;\n          break;\n        }\n      }\n      return foundIndex === index;\n    });\n    if (unique.length < 3) {\n      throw new Parse.Error(\n        Parse.Error.INTERNAL_SERVER_ERROR,\n        'GeoJSON: Loop must have at least 3 different vertices'\n      );\n    }\n    // Convert lat/long -> long/lat\n    coords = coords.map((coord) => {\n      return [coord[1], coord[0]];\n    });\n    return { type: 'Polygon', coordinates: [coords] };\n  },\n\n  isValidJSON(value) {\n    return (typeof value === 'object' &&\n      value !== null &&\n      value.__type === 'Polygon'\n    );\n  }\n};\n\nvar FileCoder = {\n  databaseToJSON(object) {\n    return {\n      __type: 'File',\n      name: object\n    }\n  },\n\n  isValidDatabaseObject(object) {\n    return (typeof object === 'string');\n  },\n\n  JSONToDatabase(json) {\n    return json.name;\n  },\n\n  isValidJSON(value) {\n    return (typeof value === 'object' &&\n      value !== null &&\n      value.__type === 'File'\n    );\n  }\n};\n\nmodule.exports = {\n  transformKey,\n  parseObjectToMongoObjectForCreate,\n  transformUpdate,\n  transformWhere,\n  mongoObjectToParseObject,\n  relativeTimeToDate,\n  transformConstraint,\n  transformPointerString,\n};\n"]} \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/PostgresClient.js b/lib/Adapters/Storage/Postgres/PostgresClient.js index 85429dfa81..debb0584fc 100644 --- a/lib/Adapters/Storage/Postgres/PostgresClient.js +++ b/lib/Adapters/Storage/Postgres/PostgresClient.js @@ -30,4 +30,5 @@ function createClient(uri, databaseOptions) { } return { client, pgp }; -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/PostgresConfigParser.js b/lib/Adapters/Storage/Postgres/PostgresConfigParser.js index 19a5112a8b..a43631ed90 100644 --- a/lib/Adapters/Storage/Postgres/PostgresConfigParser.js +++ b/lib/Adapters/Storage/Postgres/PostgresConfigParser.js @@ -43,4 +43,5 @@ function parseQueryParams(queryString) { module.exports = { parseQueryParams: parseQueryParams, getDatabaseOptionsFromURI: getDatabaseOptionsFromURI -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js b/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js index e238f40ada..5e499c41df 100644 --- a/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js +++ b/lib/Adapters/Storage/Postgres/PostgresStorageAdapter.js @@ -313,13 +313,20 @@ const buildWhereClause = ({ schema, query, index }) => { index += 2; } else if (typeof fieldValue === 'boolean') { patterns.push(`$${index}:name = $${index + 1}`); - values.push(fieldName, fieldValue); + // Can't cast boolean to double precision + if (schema.fields[fieldName] && schema.fields[fieldName].type === 'Number') { + // Should always return zero results + const MAX_INT_PLUS_ONE = 9223372036854775808; + values.push(fieldName, MAX_INT_PLUS_ONE); + } else { + values.push(fieldName, fieldValue); + } index += 2; } else if (typeof fieldValue === 'number') { patterns.push(`$${index}:name = $${index + 1}`); values.push(fieldName, fieldValue); index += 2; - } else if (fieldName === '$or' || fieldName === '$and') { + } else if (['$or', '$nor', '$and'].includes(fieldName)) { const clauses = []; const clauseValues = []; fieldValue.forEach(subQuery => { @@ -330,8 +337,11 @@ const buildWhereClause = ({ schema, query, index }) => { index += clause.values.length; } }); - const orOrAnd = fieldName === '$or' ? ' OR ' : ' AND '; - patterns.push(`(${clauses.join(orOrAnd)})`); + + const orOrAnd = fieldName === '$and' ? ' AND ' : ' OR '; + const not = fieldName === '$nor' ? ' NOT ' : ''; + + patterns.push(`${not}(${clauses.join(orOrAnd)})`); values.push(...clauseValues); } @@ -355,11 +365,16 @@ const buildWhereClause = ({ schema, query, index }) => { values.push(fieldName, fieldValue.$ne); index += 2; } - - if (fieldValue.$eq) { - patterns.push(`$${index}:name = $${index + 1}`); - values.push(fieldName, fieldValue.$eq); - index += 2; + if (fieldValue.$eq !== undefined) { + if (fieldValue.$eq === null) { + patterns.push(`$${index}:name IS NULL`); + values.push(fieldName); + index += 1; + } else { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue.$eq); + index += 2; + } } const isInOrNin = Array.isArray(fieldValue.$in) || Array.isArray(fieldValue.$nin); if (Array.isArray(fieldValue.$in) && isArrayField && schema.fields[fieldName].contents && schema.fields[fieldName].contents.type === 'String') { @@ -416,10 +431,26 @@ const buildWhereClause = ({ schema, query, index }) => { if (fieldValue.$nin) { createConstraint(_lodash2.default.flatMap(fieldValue.$nin, elt => elt), true); } + } else if (typeof fieldValue.$in !== 'undefined') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $in value'); + } else if (typeof fieldValue.$nin !== 'undefined') { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $nin value'); } if (Array.isArray(fieldValue.$all) && isArrayField) { - patterns.push(`array_contains_all($${index}:name, $${index + 1}::jsonb)`); + if (isAnyValueRegexStartsWith(fieldValue.$all)) { + if (!isAllValuesRegexOrNone(fieldValue.$all)) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'All $all values must be of regex type or none: ' + fieldValue.$all); + } + + for (let i = 0; i < fieldValue.$all.length; i += 1) { + const value = processRegexPattern(fieldValue.$all[i].$regex); + fieldValue.$all[i] = value.substring(1) + '%'; + } + patterns.push(`array_contains_all_regex($${index}:name, $${index + 1}::jsonb)`); + } else { + patterns.push(`array_contains_all($${index}:name, $${index + 1}::jsonb)`); + } values.push(fieldName, JSON.stringify(fieldValue.$all)); index += 2; } @@ -434,6 +465,17 @@ const buildWhereClause = ({ schema, query, index }) => { index += 1; } + if (fieldValue.$containedBy) { + const arr = fieldValue.$containedBy; + if (!(arr instanceof Array)) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, `bad $containedBy: should be an array`); + } + + patterns.push(`$${index}:name <@ $${index + 1}::jsonb`); + values.push(fieldName, JSON.stringify(arr)); + index += 2; + } + if (fieldValue.$text) { const search = fieldValue.$text.$search; let language = 'english'; @@ -485,15 +527,51 @@ const buildWhereClause = ({ schema, query, index }) => { index += 2; } + if (fieldValue.$geoWithin && fieldValue.$geoWithin.$centerSphere) { + const centerSphere = fieldValue.$geoWithin.$centerSphere; + if (!(centerSphere instanceof Array) || centerSphere.length < 2) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance'); + } + // Get point, convert to geo point if necessary and validate + let point = centerSphere[0]; + if (point instanceof Array && point.length === 2) { + point = new _node2.default.GeoPoint(point[1], point[0]); + } else if (!GeoPointCoder.isValidJSON(point)) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid'); + } + _node2.default.GeoPoint._validate(point.latitude, point.longitude); + // Get distance and validate + const distance = centerSphere[1]; + if (isNaN(distance) || distance < 0) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid'); + } + const distanceInKM = distance * 6371 * 1000; + patterns.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) <= $${index + 3}`); + values.push(fieldName, point.longitude, point.latitude, distanceInKM); + index += 4; + } + if (fieldValue.$geoWithin && fieldValue.$geoWithin.$polygon) { const polygon = fieldValue.$geoWithin.$polygon; - if (!(polygon instanceof Array)) { - throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); - } - if (polygon.length < 3) { - throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + let points; + if (typeof polygon === 'object' && polygon.__type === 'Polygon') { + if (!polygon.coordinates || polygon.coordinates.length < 3) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs'); + } + points = polygon.coordinates; + } else if (polygon instanceof Array) { + if (polygon.length < 3) { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'); + } + points = polygon; + } else { + throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint\'s'); } - const points = polygon.map(point => { + points = points.map(point => { + if (point instanceof Array && point.length === 2) { + _node2.default.GeoPoint._validate(point[1], point[0]); + return `(${point[0]}, ${point[1]})`; + } if (typeof point !== 'object' || point.__type !== 'GeoPoint') { throw new _node2.default.Error(_node2.default.Error.INVALID_JSON, 'bad $geoWithin value'); } else { @@ -571,7 +649,7 @@ const buildWhereClause = ({ schema, query, index }) => { } Object.keys(ParseToPosgresComparator).forEach(cmp => { - if (fieldValue[cmp]) { + if (fieldValue[cmp] || fieldValue[cmp] === 0) { const pgComparator = ParseToPosgresComparator[cmp]; patterns.push(`$${index}:name ${pgComparator} $${index + 1}`); values.push(fieldName, toPostgresValue(fieldValue[cmp])); @@ -598,7 +676,9 @@ class PostgresStorageAdapter { const { client, pgp } = (0, _PostgresClient.createClient)(uri, databaseOptions); this._client = client; this._pgp = pgp; + this.canSortOnJoinTables = false; } + // Private @@ -1220,7 +1300,7 @@ class PostgresStorageAdapter { return p + ` - '$${index + 1 + i}:value'`; }, ''); - updatePatterns.push(`$${index}:name = ( COALESCE($${index}:name, '{}'::jsonb) ${deletePatterns} ${incrementPatterns} || $${index + 1 + keysToDelete.length}::jsonb )`); + updatePatterns.push(`$${index}:name = ('{}'::jsonb ${deletePatterns} ${incrementPatterns} || $${index + 1 + keysToDelete.length}::jsonb )`); values.push(fieldName, ...keysToDelete, JSON.stringify(fieldValue)); index += 2 + keysToDelete.length; @@ -1290,11 +1370,12 @@ class PostgresStorageAdapter { if (sort) { const sortCopy = sort; const sorting = Object.keys(sort).map(key => { + const transformKey = transformDotFieldToComponents(key).join('->'); // Using $idx pattern gives: non-integer constant in ORDER BY if (sortCopy[key] === 1) { - return `"${key}" ASC`; + return `${transformKey} ASC`; } - return `"${key}" DESC`; + return `${transformKey} DESC`; }).join(); sortPattern = sort !== undefined && Object.keys(sort).length > 0 ? `ORDER BY ${sorting}` : ''; } @@ -1672,7 +1753,7 @@ class PostgresStorageAdapter { }); return Promise.all(promises).then(() => { return this._client.tx('perform-initialization', t => { - return t.batch([t.none(_sql2.default.misc.jsonObjectSetKeys), t.none(_sql2.default.array.add), t.none(_sql2.default.array.addUnique), t.none(_sql2.default.array.remove), t.none(_sql2.default.array.containsAll), t.none(_sql2.default.array.contains)]); + return t.batch([t.none(_sql2.default.misc.jsonObjectSetKeys), t.none(_sql2.default.array.add), t.none(_sql2.default.array.addUnique), t.none(_sql2.default.array.remove), t.none(_sql2.default.array.containsAll), t.none(_sql2.default.array.containsAllRegex), t.none(_sql2.default.array.contains)]); }); }).then(data => { debug(`initializationDone in ${data.duration}`); @@ -1764,6 +1845,40 @@ function processRegexPattern(s) { return literalizeRegexPart(s); } +function isStartsWithRegex(value) { + if (!value || typeof value !== 'string' || !value.startsWith('^')) { + return false; + } + + const matches = value.match(/\^\\Q.*\\E/); + return !!matches; +} + +function isAllValuesRegexOrNone(values) { + if (!values || !Array.isArray(values) || values.length === 0) { + return true; + } + + const firstValuesIsRegex = isStartsWithRegex(values[0].$regex); + if (values.length === 1) { + return firstValuesIsRegex; + } + + for (let i = 1, length = values.length; i < length; ++i) { + if (firstValuesIsRegex !== isStartsWithRegex(values[i].$regex)) { + return false; + } + } + + return true; +} + +function isAnyValueRegexStartsWith(values) { + return values.some(function (value) { + return isStartsWithRegex(value.$regex); + }); +} + function createLiteralRegex(remaining) { return remaining.split('').map(c => { if (c.match(/[0-9a-zA-Z]/) !== null) { @@ -1800,4 +1915,11 @@ function literalizeRegexPart(s) { return s.replace(/([^\\])(\\E)/, '$1').replace(/([^\\])(\\Q)/, '$1').replace(/^\\E/, '').replace(/^\\Q/, '').replace(/([^'])'/, `$1''`).replace(/^'([^'])/, `''$1`); } -exports.default = PostgresStorageAdapter; \ No newline at end of file +var GeoPointCoder = { + isValidJSON(value) { + return typeof value === 'object' && value !== null && value.__type === 'GeoPoint'; + } +}; + +exports.default = PostgresStorageAdapter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Postgres/PostgresStorageAdapter.js"],"names":["PostgresRelationDoesNotExistError","PostgresDuplicateRelationError","PostgresDuplicateColumnError","PostgresMissingColumnError","PostgresDuplicateObjectError","PostgresUniqueIndexViolationError","PostgresTransactionAbortedError","logger","require","debug","args","arguments","concat","slice","length","log","getLogger","apply","parseTypeToPostgresType","type","contents","JSON","stringify","ParseToPosgresComparator","mongoAggregateToPostgres","$dayOfMonth","$dayOfWeek","$dayOfYear","$isoDayOfWeek","$isoWeekYear","$hour","$minute","$second","$millisecond","$month","$week","$year","toPostgresValue","value","__type","iso","name","transformValue","objectId","emptyCLPS","Object","freeze","find","get","create","update","delete","addField","defaultCLPS","toParseSchema","schema","className","fields","_hashed_password","_wperm","_rperm","clps","classLevelPermissions","indexes","toPostgresSchema","_password_history","handleDotFields","object","keys","forEach","fieldName","indexOf","components","split","first","shift","currentObj","next","__op","undefined","transformDotFieldToComponents","map","cmpt","index","transformDotField","join","transformAggregateField","substr","validateKeys","key","includes","Parse","Error","INVALID_NESTED_KEY","joinTablesForSchema","list","field","push","buildWhereClause","query","patterns","values","sorts","isArrayField","initialPatternsLength","fieldValue","$exists","$in","inPatterns","listElem","$regex","MAX_INT_PLUS_ONE","clauses","clauseValues","subQuery","clause","pattern","orOrAnd","not","$ne","$eq","isInOrNin","Array","isArray","$nin","allowNull","listIndex","createConstraint","baseArray","notIn","_","flatMap","elt","INVALID_JSON","$all","isAnyValueRegexStartsWith","isAllValuesRegexOrNone","i","processRegexPattern","substring","$containedBy","arr","$text","search","$search","language","$term","$language","$caseSensitive","$diacriticSensitive","$nearSphere","point","distance","$maxDistance","distanceInKM","longitude","latitude","$within","$box","box","left","bottom","right","top","$geoWithin","$centerSphere","centerSphere","GeoPoint","GeoPointCoder","isValidJSON","_validate","isNaN","$polygon","polygon","points","coordinates","$geoIntersects","$point","regex","operator","opts","$options","removeWhiteSpace","convertPolygonToSQL","cmp","pgComparator","OPERATION_FORBIDDEN","PostgresStorageAdapter","constructor","uri","collectionPrefix","databaseOptions","_collectionPrefix","client","pgp","_client","_pgp","canSortOnJoinTables","handleShutdown","$pool","end","_ensureSchemaCollectionExists","conn","none","catch","error","code","classExists","one","a","exists","setClassLevelPermissions","CLPs","self","task","t","setIndexesWithSchemaFormat","submittedIndexes","existingIndexes","Promise","resolve","_id_","_id","deletedIndexes","insertedIndexes","INVALID_QUERY","hasOwnProperty","tx","createIndexes","dropIndexes","createClass","q1","createTable","q2","q3","batch","then","err","data","result","detail","DUPLICATE_VALUE","valuesArray","patternsArray","assign","_email_verify_token_expires_at","_email_verify_token","_account_lockout_expires_at","_failed_login_count","_perishable_token","_perishable_token_expires_at","_password_changed_at","relations","parseType","qs","joinTable","schemaUpgrade","columns","column_name","newColumns","filter","item","addFieldIfNotExists","postgresType","any","path","deleteClass","operations","helpers","deleteAllClasses","now","Date","getTime","results","joins","reduce","classes","queries","deleteFields","fieldNames","idx","getAllClasses","row","getClass","createObject","columnsArray","geoPoints","authDataMatch","match","provider","pop","initialValues","val","termination","geoPointsInjects","l","columnsPattern","col","valuesPattern","ops","underlyingError","constraint","matches","userInfo","duplicated_field","deleteObjectsByQuery","where","count","OBJECT_NOT_FOUND","findOneAndUpdate","updateObjectsByQuery","updatePatterns","originalUpdate","generate","jsonb","lastKey","fieldNameIndex","str","amount","objects","keysToIncrement","k","incrementPatterns","c","keysToDelete","deletePatterns","p","expectedType","reject","whereClause","upsertOneObject","createValue","skip","limit","sort","hasLimit","hasSkip","wherePattern","limitPattern","skipPattern","sortPattern","sortCopy","sorting","transformKey","postgresObjectToParseObject","targetClass","y","x","coords","parseFloat","createdAt","toISOString","updatedAt","expiresAt","ensureUniqueness","constraintName","constraintPatterns","message","distinct","column","isNested","isPointerField","transformer","child","aggregate","pipeline","countField","groupValues","groupPattern","stage","$group","groupByFields","alias","operation","source","$sum","$max","$min","$avg","$project","$match","$or","collapse","element","matchPatterns","$limit","$skip","$sort","order","parseInt","performInitialization","VolatileClassesSchemas","promises","INVALID_CLASS_NAME","all","sql","misc","jsonObjectSetKeys","array","add","addUnique","remove","containsAll","containsAllRegex","contains","duration","console","createIndexesIfNeeded","getIndexes","updateSchemaWithIndexes","unique","ar","foundIndex","pt","INTERNAL_SERVER_ERROR","endsWith","replace","trim","s","startsWith","literalizeRegexPart","isStartsWithRegex","firstValuesIsRegex","some","createLiteralRegex","remaining","matcher1","result1","prefix","matcher2","result2"],"mappings":"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","file":"PostgresStorageAdapter.js","sourcesContent":["// @flow\nimport { createClient } from './PostgresClient';\n// @flow-disable-next\nimport Parse            from 'parse/node';\n// @flow-disable-next\nimport _                from 'lodash';\nimport sql              from './sql';\n\nconst PostgresRelationDoesNotExistError = '42P01';\nconst PostgresDuplicateRelationError = '42P07';\nconst PostgresDuplicateColumnError = '42701';\nconst PostgresMissingColumnError = '42703';\nconst PostgresDuplicateObjectError = '42710';\nconst PostgresUniqueIndexViolationError = '23505';\nconst PostgresTransactionAbortedError = '25P02';\nconst logger = require('../../../logger');\n\nconst debug = function(...args: any) {\n  args = ['PG: ' + arguments[0]].concat(args.slice(1, args.length));\n  const log = logger.getLogger();\n  log.debug.apply(log, args);\n}\n\nimport { StorageAdapter }    from '../StorageAdapter';\nimport type { SchemaType,\n  QueryType,\n  QueryOptions } from '../StorageAdapter';\n\nconst parseTypeToPostgresType = type => {\n  switch (type.type) {\n  case 'String': return 'text';\n  case 'Date': return 'timestamp with time zone';\n  case 'Object': return 'jsonb';\n  case 'File': return 'text';\n  case 'Boolean': return 'boolean';\n  case 'Pointer': return 'char(10)';\n  case 'Number': return 'double precision';\n  case 'GeoPoint': return 'point';\n  case 'Bytes': return 'jsonb';\n  case 'Polygon': return 'polygon';\n  case 'Array':\n    if (type.contents && type.contents.type === 'String') {\n      return 'text[]';\n    } else {\n      return 'jsonb';\n    }\n  default: throw `no type for ${JSON.stringify(type)} yet`;\n  }\n};\n\nconst ParseToPosgresComparator = {\n  '$gt': '>',\n  '$lt': '<',\n  '$gte': '>=',\n  '$lte': '<='\n}\n\nconst mongoAggregateToPostgres = {\n  $dayOfMonth: 'DAY',\n  $dayOfWeek: 'DOW',\n  $dayOfYear: 'DOY',\n  $isoDayOfWeek: 'ISODOW',\n  $isoWeekYear:'ISOYEAR',\n  $hour: 'HOUR',\n  $minute: 'MINUTE',\n  $second: 'SECOND',\n  $millisecond: 'MILLISECONDS',\n  $month: 'MONTH',\n  $week: 'WEEK',\n  $year: 'YEAR',\n};\n\nconst toPostgresValue = value => {\n  if (typeof value === 'object') {\n    if (value.__type === 'Date') {\n      return value.iso;\n    }\n    if (value.__type === 'File') {\n      return value.name;\n    }\n  }\n  return value;\n}\n\nconst transformValue = value => {\n  if (typeof value === 'object' &&\n        value.__type === 'Pointer') {\n    return value.objectId;\n  }\n  return value;\n}\n\n// Duplicate from then mongo adapter...\nconst emptyCLPS = Object.freeze({\n  find: {},\n  get: {},\n  create: {},\n  update: {},\n  delete: {},\n  addField: {},\n});\n\nconst defaultCLPS = Object.freeze({\n  find: {'*': true},\n  get: {'*': true},\n  create: {'*': true},\n  update: {'*': true},\n  delete: {'*': true},\n  addField: {'*': true},\n});\n\nconst toParseSchema = (schema) => {\n  if (schema.className === '_User') {\n    delete schema.fields._hashed_password;\n  }\n  if (schema.fields) {\n    delete schema.fields._wperm;\n    delete schema.fields._rperm;\n  }\n  let clps = defaultCLPS;\n  if (schema.classLevelPermissions) {\n    clps = {...emptyCLPS, ...schema.classLevelPermissions};\n  }\n  let indexes = {};\n  if (schema.indexes) {\n    indexes = {...schema.indexes};\n  }\n  return {\n    className: schema.className,\n    fields: schema.fields,\n    classLevelPermissions: clps,\n    indexes,\n  };\n}\n\nconst toPostgresSchema = (schema) => {\n  if (!schema) {\n    return schema;\n  }\n  schema.fields = schema.fields || {};\n  schema.fields._wperm = {type: 'Array', contents: {type: 'String'}}\n  schema.fields._rperm = {type: 'Array', contents: {type: 'String'}}\n  if (schema.className === '_User') {\n    schema.fields._hashed_password = {type: 'String'};\n    schema.fields._password_history = {type: 'Array'};\n  }\n  return schema;\n}\n\nconst handleDotFields = (object) => {\n  Object.keys(object).forEach(fieldName => {\n    if (fieldName.indexOf('.') > -1) {\n      const components = fieldName.split('.');\n      const first = components.shift();\n      object[first] = object[first] || {};\n      let currentObj = object[first];\n      let next;\n      let value = object[fieldName];\n      if (value && value.__op === 'Delete') {\n        value = undefined;\n      }\n      /* eslint-disable no-cond-assign */\n      while(next = components.shift()) {\n      /* eslint-enable no-cond-assign */\n        currentObj[next] = currentObj[next] || {};\n        if (components.length === 0) {\n          currentObj[next] = value;\n        }\n        currentObj = currentObj[next];\n      }\n      delete object[fieldName];\n    }\n  });\n  return object;\n}\n\nconst transformDotFieldToComponents = (fieldName) => {\n  return fieldName.split('.').map((cmpt, index) => {\n    if (index === 0) {\n      return `\"${cmpt}\"`;\n    }\n    return `'${cmpt}'`;\n  });\n}\n\nconst transformDotField = (fieldName) => {\n  if (fieldName.indexOf('.') === -1) {\n    return `\"${fieldName}\"`;\n  }\n  const components = transformDotFieldToComponents(fieldName);\n  let name = components.slice(0, components.length - 1).join('->');\n  name += '->>' + components[components.length - 1];\n  return name;\n}\n\nconst transformAggregateField = (fieldName) => {\n  if (typeof fieldName !== 'string') {\n    return fieldName;\n  }\n  if (fieldName === '$_created_at') {\n    return 'createdAt';\n  }\n  if (fieldName === '$_updated_at') {\n    return 'updatedAt';\n  }\n  return fieldName.substr(1);\n}\n\nconst validateKeys = (object) => {\n  if (typeof object == 'object') {\n    for (const key in object) {\n      if (typeof object[key] == 'object') {\n        validateKeys(object[key]);\n      }\n\n      if(key.includes('$') || key.includes('.')){\n        throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, \"Nested keys should not contain the '$' or '.' characters\");\n      }\n    }\n  }\n}\n\n// Returns the list of join tables on a schema\nconst joinTablesForSchema = (schema) => {\n  const list = [];\n  if (schema) {\n    Object.keys(schema.fields).forEach((field) => {\n      if (schema.fields[field].type === 'Relation') {\n        list.push(`_Join:${field}:${schema.className}`);\n      }\n    });\n  }\n  return list;\n}\n\ninterface WhereClause {\n  pattern: string;\n  values: Array<any>;\n  sorts: Array<any>;\n}\n\nconst buildWhereClause = ({ schema, query, index }): WhereClause => {\n  const patterns = [];\n  let values = [];\n  const sorts = [];\n\n  schema = toPostgresSchema(schema);\n  for (const fieldName in query) {\n    const isArrayField = schema.fields\n          && schema.fields[fieldName]\n          && schema.fields[fieldName].type === 'Array';\n    const initialPatternsLength = patterns.length;\n    const fieldValue = query[fieldName];\n\n    // nothingin the schema, it's gonna blow up\n    if (!schema.fields[fieldName]) {\n      // as it won't exist\n      if (fieldValue && fieldValue.$exists === false) {\n        continue;\n      }\n    }\n\n    if (fieldName.indexOf('.') >= 0) {\n      let name = transformDotField(fieldName);\n      if (fieldValue === null) {\n        patterns.push(`${name} IS NULL`);\n      } else {\n        if (fieldValue.$in) {\n          const inPatterns = [];\n          name = transformDotFieldToComponents(fieldName).join('->');\n          fieldValue.$in.forEach((listElem) => {\n            if (typeof listElem === 'string') {\n              inPatterns.push(`\"${listElem}\"`);\n            } else {\n              inPatterns.push(`${listElem}`);\n            }\n          });\n          patterns.push(`(${name})::jsonb @> '[${inPatterns.join()}]'::jsonb`);\n        } else if (fieldValue.$regex) {\n          // Handle later\n        } else {\n          patterns.push(`${name} = '${fieldValue}'`);\n        }\n      }\n    } else if (fieldValue === null || fieldValue === undefined) {\n      patterns.push(`$${index}:name IS NULL`);\n      values.push(fieldName);\n      index += 1;\n      continue;\n    } else if (typeof fieldValue === 'string') {\n      patterns.push(`$${index}:name = $${index + 1}`);\n      values.push(fieldName, fieldValue);\n      index += 2;\n    } else if (typeof fieldValue === 'boolean') {\n      patterns.push(`$${index}:name = $${index + 1}`);\n      // Can't cast boolean to double precision\n      if (schema.fields[fieldName] && schema.fields[fieldName].type === 'Number') {\n        // Should always return zero results\n        const MAX_INT_PLUS_ONE = 9223372036854775808;\n        values.push(fieldName, MAX_INT_PLUS_ONE);\n      } else {\n        values.push(fieldName, fieldValue);\n      }\n      index += 2;\n    } else if (typeof fieldValue === 'number') {\n      patterns.push(`$${index}:name = $${index + 1}`);\n      values.push(fieldName, fieldValue);\n      index += 2;\n    } else if (['$or', '$nor', '$and'].includes(fieldName)) {\n      const clauses = [];\n      const clauseValues = [];\n      fieldValue.forEach((subQuery) =>  {\n        const clause = buildWhereClause({ schema, query: subQuery, index });\n        if (clause.pattern.length > 0) {\n          clauses.push(clause.pattern);\n          clauseValues.push(...clause.values);\n          index += clause.values.length;\n        }\n      });\n\n      const orOrAnd = fieldName === '$and' ? ' AND ' : ' OR ';\n      const not = fieldName === '$nor' ? ' NOT ' : '';\n\n      patterns.push(`${not}(${clauses.join(orOrAnd)})`);\n      values.push(...clauseValues);\n    }\n\n    if (fieldValue.$ne !== undefined) {\n      if (isArrayField) {\n        fieldValue.$ne = JSON.stringify([fieldValue.$ne]);\n        patterns.push(`NOT array_contains($${index}:name, $${index + 1})`);\n      } else {\n        if (fieldValue.$ne === null) {\n          patterns.push(`$${index}:name IS NOT NULL`);\n          values.push(fieldName);\n          index += 1;\n          continue;\n        } else {\n          // if not null, we need to manually exclude null\n          patterns.push(`($${index}:name <> $${index + 1} OR $${index}:name IS NULL)`);\n        }\n      }\n\n      // TODO: support arrays\n      values.push(fieldName, fieldValue.$ne);\n      index += 2;\n    }\n    if (fieldValue.$eq !== undefined) {\n      if (fieldValue.$eq === null) {\n        patterns.push(`$${index}:name IS NULL`);\n        values.push(fieldName);\n        index += 1;\n      } else {\n        patterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue.$eq);\n        index += 2;\n      }\n    }\n    const isInOrNin = Array.isArray(fieldValue.$in) || Array.isArray(fieldValue.$nin);\n    if (Array.isArray(fieldValue.$in) &&\n        isArrayField &&\n        schema.fields[fieldName].contents &&\n        schema.fields[fieldName].contents.type === 'String') {\n      const inPatterns = [];\n      let allowNull = false;\n      values.push(fieldName);\n      fieldValue.$in.forEach((listElem, listIndex) => {\n        if (listElem === null) {\n          allowNull = true;\n        } else {\n          values.push(listElem);\n          inPatterns.push(`$${index + 1 + listIndex - (allowNull ? 1 : 0)}`);\n        }\n      });\n      if (allowNull) {\n        patterns.push(`($${index}:name IS NULL OR $${index}:name && ARRAY[${inPatterns.join()}])`);\n      } else {\n        patterns.push(`$${index}:name && ARRAY[${inPatterns.join()}]`);\n      }\n      index = index + 1 + inPatterns.length;\n    } else if (isInOrNin) {\n      var createConstraint = (baseArray, notIn) => {\n        if (baseArray.length > 0) {\n          const not = notIn ? ' NOT ' : '';\n          if (isArrayField) {\n            patterns.push(`${not} array_contains($${index}:name, $${index + 1})`);\n            values.push(fieldName, JSON.stringify(baseArray));\n            index += 2;\n          } else {\n            // Handle Nested Dot Notation Above\n            if (fieldName.indexOf('.') >= 0) {\n              return;\n            }\n            const inPatterns = [];\n            values.push(fieldName);\n            baseArray.forEach((listElem, listIndex) => {\n              if (listElem !== null) {\n                values.push(listElem);\n                inPatterns.push(`$${index + 1 + listIndex}`);\n              }\n            });\n            patterns.push(`$${index}:name ${not} IN (${inPatterns.join()})`);\n            index = index + 1 + inPatterns.length;\n          }\n        } else if (!notIn) {\n          values.push(fieldName);\n          patterns.push(`$${index}:name IS NULL`);\n          index = index + 1;\n        }\n      }\n      if (fieldValue.$in) {\n        createConstraint(_.flatMap(fieldValue.$in, elt => elt), false);\n      }\n      if (fieldValue.$nin) {\n        createConstraint(_.flatMap(fieldValue.$nin, elt => elt), true);\n      }\n    } else if(typeof fieldValue.$in !== 'undefined') {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $in value');\n    } else if (typeof fieldValue.$nin !== 'undefined') {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $nin value');\n    }\n\n    if (Array.isArray(fieldValue.$all) && isArrayField) {\n      if (isAnyValueRegexStartsWith(fieldValue.$all)) {\n        if (!isAllValuesRegexOrNone(fieldValue.$all)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'All $all values must be of regex type or none: '\n            + fieldValue.$all);\n        }\n\n        for (let i = 0; i < fieldValue.$all.length; i += 1) {\n          const value = processRegexPattern(fieldValue.$all[i].$regex);\n          fieldValue.$all[i] = value.substring(1) + '%';\n        }\n        patterns.push(`array_contains_all_regex($${index}:name, $${index + 1}::jsonb)`);\n      } else {\n        patterns.push(`array_contains_all($${index}:name, $${index + 1}::jsonb)`);\n      }\n      values.push(fieldName, JSON.stringify(fieldValue.$all));\n      index += 2;\n    }\n\n    if (typeof fieldValue.$exists !== 'undefined') {\n      if (fieldValue.$exists) {\n        patterns.push(`$${index}:name IS NOT NULL`);\n      } else {\n        patterns.push(`$${index}:name IS NULL`);\n      }\n      values.push(fieldName);\n      index += 1;\n    }\n\n    if (fieldValue.$containedBy) {\n      const arr = fieldValue.$containedBy;\n      if (!(arr instanceof Array)) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $containedBy: should be an array`\n        );\n      }\n\n      patterns.push(`$${index}:name <@ $${index + 1}::jsonb`);\n      values.push(fieldName, JSON.stringify(arr));\n      index += 2;\n    }\n\n    if (fieldValue.$text) {\n      const search = fieldValue.$text.$search;\n      let language = 'english';\n      if (typeof search !== 'object') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $search, should be object`\n        );\n      }\n      if (!search.$term || typeof search.$term !== 'string') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $term, should be string`\n        );\n      }\n      if (search.$language && typeof search.$language !== 'string') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $language, should be string`\n        );\n      } else if (search.$language) {\n        language = search.$language;\n      }\n      if (search.$caseSensitive && typeof search.$caseSensitive !== 'boolean') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $caseSensitive, should be boolean`\n        );\n      } else if (search.$caseSensitive) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $caseSensitive not supported, please use $regex or create a separate lower case column.`\n        );\n      }\n      if (search.$diacriticSensitive && typeof search.$diacriticSensitive !== 'boolean') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $diacriticSensitive, should be boolean`\n        );\n      } else if (search.$diacriticSensitive === false) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          `bad $text: $diacriticSensitive - false not supported, install Postgres Unaccent Extension`\n        );\n      }\n      patterns.push(`to_tsvector($${index}, $${index + 1}:name) @@ to_tsquery($${index + 2}, $${index + 3})`);\n      values.push(language, fieldName, language, search.$term);\n      index += 4;\n    }\n\n    if (fieldValue.$nearSphere) {\n      const point = fieldValue.$nearSphere;\n      const distance = fieldValue.$maxDistance;\n      const distanceInKM = distance * 6371 * 1000;\n      patterns.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) <= $${index + 3}`);\n      sorts.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) ASC`)\n      values.push(fieldName, point.longitude, point.latitude, distanceInKM);\n      index += 4;\n    }\n\n    if (fieldValue.$within && fieldValue.$within.$box) {\n      const box = fieldValue.$within.$box;\n      const left = box[0].longitude;\n      const bottom = box[0].latitude;\n      const right = box[1].longitude;\n      const top = box[1].latitude;\n\n      patterns.push(`$${index}:name::point <@ $${index + 1}::box`);\n      values.push(fieldName, `((${left}, ${bottom}), (${right}, ${top}))`);\n      index += 2;\n    }\n\n    if (fieldValue.$geoWithin && fieldValue.$geoWithin.$centerSphere) {\n      const centerSphere = fieldValue.$geoWithin.$centerSphere;\n      if (!(centerSphere instanceof Array) || centerSphere.length < 2) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance');\n      }\n      // Get point, convert to geo point if necessary and validate\n      let point = centerSphere[0];\n      if (point instanceof Array && point.length === 2) {\n        point = new Parse.GeoPoint(point[1], point[0]);\n      } else if (!GeoPointCoder.isValidJSON(point)) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid');\n      }\n      Parse.GeoPoint._validate(point.latitude, point.longitude);\n      // Get distance and validate\n      const distance = centerSphere[1];\n      if(isNaN(distance) || distance < 0) {\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid');\n      }\n      const distanceInKM = distance * 6371 * 1000;\n      patterns.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) <= $${index + 3}`);\n      values.push(fieldName, point.longitude, point.latitude, distanceInKM);\n      index += 4;\n    }\n\n    if (fieldValue.$geoWithin && fieldValue.$geoWithin.$polygon) {\n      const polygon = fieldValue.$geoWithin.$polygon;\n      let points;\n      if (typeof polygon === 'object' && polygon.__type === 'Polygon') {\n        if (!polygon.coordinates || polygon.coordinates.length < 3) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs'\n          );\n        }\n        points = polygon.coordinates;\n      } else if ((polygon instanceof Array)) {\n        if (polygon.length < 3) {\n          throw new Parse.Error(\n            Parse.Error.INVALID_JSON,\n            'bad $geoWithin value; $polygon should contain at least 3 GeoPoints'\n          );\n        }\n        points = polygon;\n      } else {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          'bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint\\'s'\n        );\n      }\n      points = points.map((point) => {\n        if (point instanceof Array && point.length === 2) {\n          Parse.GeoPoint._validate(point[1], point[0]);\n          return `(${point[0]}, ${point[1]})`;\n        }\n        if (typeof point !== 'object' || point.__type !== 'GeoPoint') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value');\n        } else {\n          Parse.GeoPoint._validate(point.latitude, point.longitude);\n        }\n        return `(${point.longitude}, ${point.latitude})`;\n      }).join(', ');\n\n      patterns.push(`$${index}:name::point <@ $${index + 1}::polygon`);\n      values.push(fieldName, `(${points})`);\n      index += 2;\n    }\n    if (fieldValue.$geoIntersects && fieldValue.$geoIntersects.$point) {\n      const point = fieldValue.$geoIntersects.$point;\n      if (typeof point !== 'object' || point.__type !== 'GeoPoint') {\n        throw new Parse.Error(\n          Parse.Error.INVALID_JSON,\n          'bad $geoIntersect value; $point should be GeoPoint'\n        );\n      } else {\n        Parse.GeoPoint._validate(point.latitude, point.longitude);\n      }\n      patterns.push(`$${index}:name::polygon @> $${index + 1}::point`);\n      values.push(fieldName, `(${point.longitude}, ${point.latitude})`);\n      index += 2;\n    }\n\n    if (fieldValue.$regex) {\n      let regex = fieldValue.$regex;\n      let operator = '~';\n      const opts = fieldValue.$options;\n      if (opts) {\n        if (opts.indexOf('i') >= 0) {\n          operator = '~*';\n        }\n        if (opts.indexOf('x') >= 0) {\n          regex = removeWhiteSpace(regex);\n        }\n      }\n\n      const name = transformDotField(fieldName);\n      regex = processRegexPattern(regex);\n\n      patterns.push(`$${index}:raw ${operator} '$${index + 1}:raw'`);\n      values.push(name, regex);\n      index += 2;\n    }\n\n    if (fieldValue.__type === 'Pointer') {\n      if (isArrayField) {\n        patterns.push(`array_contains($${index}:name, $${index + 1})`);\n        values.push(fieldName, JSON.stringify([fieldValue]));\n        index += 2;\n      } else {\n        patterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue.objectId);\n        index += 2;\n      }\n    }\n\n    if (fieldValue.__type === 'Date') {\n      patterns.push(`$${index}:name = $${index + 1}`);\n      values.push(fieldName, fieldValue.iso);\n      index += 2;\n    }\n\n    if (fieldValue.__type === 'GeoPoint') {\n      patterns.push('$' + index + ':name ~= POINT($' + (index + 1) + ', $' + (index + 2) + ')');\n      values.push(fieldName, fieldValue.longitude, fieldValue.latitude);\n      index += 3;\n    }\n\n    if (fieldValue.__type === 'Polygon') {\n      const value = convertPolygonToSQL(fieldValue.coordinates);\n      patterns.push(`$${index}:name ~= $${index + 1}::polygon`);\n      values.push(fieldName, value);\n      index += 2;\n    }\n\n    Object.keys(ParseToPosgresComparator).forEach(cmp => {\n      if (fieldValue[cmp] || fieldValue[cmp] === 0) {\n        const pgComparator = ParseToPosgresComparator[cmp];\n        patterns.push(`$${index}:name ${pgComparator} $${index + 1}`);\n        values.push(fieldName, toPostgresValue(fieldValue[cmp]));\n        index += 2;\n      }\n    });\n\n    if (initialPatternsLength === patterns.length) {\n      throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, `Postgres doesn't support this query type yet ${JSON.stringify(fieldValue)}`);\n    }\n  }\n  values = values.map(transformValue);\n  return { pattern: patterns.join(' AND '), values, sorts };\n}\n\nexport class PostgresStorageAdapter implements StorageAdapter {\n\n  canSortOnJoinTables: boolean;\n\n  // Private\n  _collectionPrefix: string;\n  _client: any;\n  _pgp: any;\n\n  constructor({\n    uri,\n    collectionPrefix = '',\n    databaseOptions\n  }: any) {\n    this._collectionPrefix = collectionPrefix;\n    const { client, pgp } = createClient(uri, databaseOptions);\n    this._client = client;\n    this._pgp = pgp;\n    this.canSortOnJoinTables = false;\n  }\n\n  handleShutdown() {\n    if (!this._client) {\n      return;\n    }\n    this._client.$pool.end();\n  }\n\n  _ensureSchemaCollectionExists(conn: any) {\n    conn = conn || this._client;\n    return conn.none('CREATE TABLE IF NOT EXISTS \"_SCHEMA\" ( \"className\" varChar(120), \"schema\" jsonb, \"isParseClass\" bool, PRIMARY KEY (\"className\") )')\n      .catch(error => {\n        if (error.code === PostgresDuplicateRelationError\n          || error.code === PostgresUniqueIndexViolationError\n          || error.code === PostgresDuplicateObjectError) {\n        // Table already exists, must have been created by a different request. Ignore error.\n        } else {\n          throw error;\n        }\n      });\n  }\n\n  classExists(name: string) {\n    return this._client.one('SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1)', [name], a => a.exists);\n  }\n\n  setClassLevelPermissions(className: string, CLPs: any) {\n    const self = this;\n    return this._client.task('set-class-level-permissions', function * (t) {\n      yield self._ensureSchemaCollectionExists(t);\n      const values = [className, 'schema', 'classLevelPermissions', JSON.stringify(CLPs)];\n      yield t.none(`UPDATE \"_SCHEMA\" SET $2:name = json_object_set_key($2:name, $3::text, $4::jsonb) WHERE \"className\"=$1`, values);\n    });\n  }\n\n  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any, conn: ?any): Promise<void> {\n    conn = conn || this._client;\n    const self = this;\n    if (submittedIndexes === undefined) {\n      return Promise.resolve();\n    }\n    if (Object.keys(existingIndexes).length === 0) {\n      existingIndexes = { _id_: { _id: 1} };\n    }\n    const deletedIndexes = [];\n    const insertedIndexes = [];\n    Object.keys(submittedIndexes).forEach(name => {\n      const field = submittedIndexes[name];\n      if (existingIndexes[name] && field.__op !== 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`);\n      }\n      if (!existingIndexes[name] && field.__op === 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`);\n      }\n      if (field.__op === 'Delete') {\n        deletedIndexes.push(name);\n        delete existingIndexes[name];\n      } else {\n        Object.keys(field).forEach(key => {\n          if (!fields.hasOwnProperty(key)) {\n            throw new Parse.Error(Parse.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`);\n          }\n        });\n        existingIndexes[name] = field;\n        insertedIndexes.push({\n          key: field,\n          name,\n        });\n      }\n    });\n    return conn.tx('set-indexes-with-schema-format', function * (t) {\n      if (insertedIndexes.length > 0) {\n        yield self.createIndexes(className, insertedIndexes, t);\n      }\n      if (deletedIndexes.length > 0) {\n        yield self.dropIndexes(className, deletedIndexes, t);\n      }\n      yield self._ensureSchemaCollectionExists(t);\n      yield t.none('UPDATE \"_SCHEMA\" SET $2:name = json_object_set_key($2:name, $3::text, $4::jsonb) WHERE \"className\"=$1', [className, 'schema', 'indexes', JSON.stringify(existingIndexes)]);\n    });\n  }\n\n  createClass(className: string, schema: SchemaType, conn: ?any) {\n    conn = conn || this._client;\n    return conn.tx('create-class', t => {\n      const q1 = this.createTable(className, schema, t);\n      const q2 = t.none('INSERT INTO \"_SCHEMA\" (\"className\", \"schema\", \"isParseClass\") VALUES ($<className>, $<schema>, true)', { className, schema });\n      const q3 = this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields, t);\n      return t.batch([q1, q2, q3]);\n    })\n      .then(() => {\n        return toParseSchema(schema);\n      })\n      .catch(err => {\n        if (err.data[0].result.code === PostgresTransactionAbortedError) {\n          err = err.data[1].result;\n        }\n        if (err.code === PostgresUniqueIndexViolationError && err.detail.includes(className)) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, `Class ${className} already exists.`)\n        }\n        throw err;\n      })\n  }\n\n  // Just create a table, do not insert in schema\n  createTable(className: string, schema: SchemaType, conn: any) {\n    conn = conn || this._client;\n    const self = this;\n    debug('createTable', className, schema);\n    const valuesArray = [];\n    const patternsArray = [];\n    const fields = Object.assign({}, schema.fields);\n    if (className === '_User') {\n      fields._email_verify_token_expires_at = {type: 'Date'};\n      fields._email_verify_token = {type: 'String'};\n      fields._account_lockout_expires_at = {type: 'Date'};\n      fields._failed_login_count = {type: 'Number'};\n      fields._perishable_token = {type: 'String'};\n      fields._perishable_token_expires_at = {type: 'Date'};\n      fields._password_changed_at = {type: 'Date'};\n      fields._password_history = { type: 'Array'};\n    }\n    let index = 2;\n    const relations = [];\n    Object.keys(fields).forEach((fieldName) => {\n      const parseType = fields[fieldName];\n      // Skip when it's a relation\n      // We'll create the tables later\n      if (parseType.type === 'Relation') {\n        relations.push(fieldName)\n        return;\n      }\n      if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) {\n        parseType.contents = { type: 'String' };\n      }\n      valuesArray.push(fieldName);\n      valuesArray.push(parseTypeToPostgresType(parseType));\n      patternsArray.push(`$${index}:name $${index + 1}:raw`);\n      if (fieldName === 'objectId') {\n        patternsArray.push(`PRIMARY KEY ($${index}:name)`)\n      }\n      index = index + 2;\n    });\n    const qs = `CREATE TABLE IF NOT EXISTS $1:name (${patternsArray.join()})`;\n    const values = [className, ...valuesArray];\n\n    return conn.task('create-table', function * (t) {\n      try {\n        yield self._ensureSchemaCollectionExists(t);\n        yield t.none(qs, values);\n      } catch(error) {\n        if (error.code !== PostgresDuplicateRelationError) {\n          throw error;\n        }\n        // ELSE: Table already exists, must have been created by a different request. Ignore the error.\n      }\n      yield t.tx('create-table-tx', tx => {\n        return tx.batch(relations.map(fieldName => {\n          return tx.none('CREATE TABLE IF NOT EXISTS $<joinTable:name> (\"relatedId\" varChar(120), \"owningId\" varChar(120), PRIMARY KEY(\"relatedId\", \"owningId\") )', {joinTable: `_Join:${fieldName}:${className}`});\n        }));\n      });\n    });\n  }\n\n  schemaUpgrade(className: string, schema: SchemaType, conn: any) {\n    debug('schemaUpgrade', { className, schema });\n    conn = conn || this._client;\n    const self = this;\n\n    return conn.tx('schema-upgrade', function * (t) {\n      const columns = yield t.map('SELECT column_name FROM information_schema.columns WHERE table_name = $<className>', { className }, a => a.column_name);\n      const newColumns = Object.keys(schema.fields)\n        .filter(item => columns.indexOf(item) === -1)\n        .map(fieldName => self.addFieldIfNotExists(className, fieldName, schema.fields[fieldName], t));\n\n      yield t.batch(newColumns);\n    });\n  }\n\n  addFieldIfNotExists(className: string, fieldName: string, type: any, conn: any) {\n    // TODO: Must be revised for invalid logic...\n    debug('addFieldIfNotExists', {className, fieldName, type});\n    conn = conn || this._client;\n    const self = this;\n    return conn.tx('add-field-if-not-exists', function * (t) {\n      if (type.type !== 'Relation') {\n        try {\n          yield t.none('ALTER TABLE $<className:name> ADD COLUMN $<fieldName:name> $<postgresType:raw>', {\n            className,\n            fieldName,\n            postgresType: parseTypeToPostgresType(type)\n          });\n        } catch(error) {\n          if (error.code === PostgresRelationDoesNotExistError) {\n            return yield self.createClass(className, {fields: {[fieldName]: type}}, t);\n          }\n          if (error.code !== PostgresDuplicateColumnError) {\n            throw error;\n          }\n          // Column already exists, created by other request. Carry on to see if it's the right type.\n        }\n      } else {\n        yield t.none('CREATE TABLE IF NOT EXISTS $<joinTable:name> (\"relatedId\" varChar(120), \"owningId\" varChar(120), PRIMARY KEY(\"relatedId\", \"owningId\") )', {joinTable: `_Join:${fieldName}:${className}`});\n      }\n\n      const result = yield t.any('SELECT \"schema\" FROM \"_SCHEMA\" WHERE \"className\" = $<className> and (\"schema\"::json->\\'fields\\'->$<fieldName>) is not null', {className, fieldName});\n\n      if (result[0]) {\n        throw 'Attempted to add a field that already exists';\n      } else {\n        const path = `{fields,${fieldName}}`;\n        yield t.none('UPDATE \"_SCHEMA\" SET \"schema\"=jsonb_set(\"schema\", $<path>, $<type>)  WHERE \"className\"=$<className>', {path, type, className});\n      }\n    });\n  }\n\n  // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)\n  // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.\n  deleteClass(className: string) {\n    const operations = [\n      {query: `DROP TABLE IF EXISTS $1:name`, values: [className]},\n      {query: `DELETE FROM \"_SCHEMA\" WHERE \"className\" = $1`, values: [className]}\n    ];\n    return this._client.tx(t => t.none(this._pgp.helpers.concat(operations)))\n      .then(() => className.indexOf('_Join:') != 0); // resolves with false when _Join table\n  }\n\n  // Delete all data known to this adapter. Used for testing.\n  deleteAllClasses() {\n    const now = new Date().getTime();\n    const helpers = this._pgp.helpers;\n    debug('deleteAllClasses');\n\n    return this._client.task('delete-all-classes', function * (t) {\n      try {\n        const results = yield t.any('SELECT * FROM \"_SCHEMA\"');\n        const joins = results.reduce((list: Array<string>, schema: any) => {\n          return list.concat(joinTablesForSchema(schema.schema));\n        }, []);\n        const classes = ['_SCHEMA', '_PushStatus', '_JobStatus', '_JobSchedule', '_Hooks', '_GlobalConfig', '_Audience', ...results.map(result => result.className), ...joins];\n        const queries = classes.map(className => ({query: 'DROP TABLE IF EXISTS $<className:name>', values: {className}}));\n        yield t.tx(tx => tx.none(helpers.concat(queries)));\n      } catch(error) {\n        if (error.code !== PostgresRelationDoesNotExistError) {\n          throw error;\n        }\n        // No _SCHEMA collection. Don't delete anything.\n      }\n    })\n      .then(() => {\n        debug(`deleteAllClasses done in ${new Date().getTime() - now}`);\n      });\n  }\n\n  // Remove the column and all the data. For Relations, the _Join collection is handled\n  // specially, this function does not delete _Join columns. It should, however, indicate\n  // that the relation fields does not exist anymore. In mongo, this means removing it from\n  // the _SCHEMA collection.  There should be no actual data in the collection under the same name\n  // as the relation column, so it's fine to attempt to delete it. If the fields listed to be\n  // deleted do not exist, this function should return successfully anyways. Checking for\n  // attempts to delete non-existent fields is the responsibility of Parse Server.\n\n  // This function is not obligated to delete fields atomically. It is given the field\n  // names in a list so that databases that are capable of deleting fields atomically\n  // may do so.\n\n  // Returns a Promise.\n  deleteFields(className: string, schema: SchemaType, fieldNames: string[]): Promise<void> {\n    debug('deleteFields', className, fieldNames);\n    fieldNames = fieldNames.reduce((list: Array<string>, fieldName: string) => {\n      const field = schema.fields[fieldName]\n      if (field.type !== 'Relation') {\n        list.push(fieldName);\n      }\n      delete schema.fields[fieldName];\n      return list;\n    }, []);\n\n    const values = [className, ...fieldNames];\n    const columns = fieldNames.map((name, idx) => {\n      return `$${idx + 2}:name`;\n    }).join(', DROP COLUMN');\n\n    return this._client.tx('delete-fields', function * (t) {\n      yield t.none('UPDATE \"_SCHEMA\" SET \"schema\"=$<schema> WHERE \"className\"=$<className>', {schema, className});\n      if (values.length > 1) {\n        yield t.none(`ALTER TABLE $1:name DROP COLUMN ${columns}`, values);\n      }\n    });\n  }\n\n  // Return a promise for all schemas known to this adapter, in Parse format. In case the\n  // schemas cannot be retrieved, returns a promise that rejects. Requirements for the\n  // rejection reason are TBD.\n  getAllClasses() {\n    const self = this;\n    return this._client.task('get-all-classes', function * (t) {\n      yield self._ensureSchemaCollectionExists(t);\n      return yield t.map('SELECT * FROM \"_SCHEMA\"', null, row => toParseSchema({ className: row.className, ...row.schema }));\n    });\n  }\n\n  // Return a promise for the schema with the given name, in Parse format. If\n  // this adapter doesn't know about the schema, return a promise that rejects with\n  // undefined as the reason.\n  getClass(className: string) {\n    debug('getClass', className);\n    return this._client.any('SELECT * FROM \"_SCHEMA\" WHERE \"className\"=$<className>', { className })\n      .then(result => {\n        if (result.length !== 1) {\n          throw undefined;\n        }\n        return result[0].schema;\n      })\n      .then(toParseSchema);\n  }\n\n  // TODO: remove the mongo format dependency in the return value\n  createObject(className: string, schema: SchemaType, object: any) {\n    debug('createObject', className, object);\n    let columnsArray = [];\n    const valuesArray = [];\n    schema = toPostgresSchema(schema);\n    const geoPoints = {};\n\n    object = handleDotFields(object);\n\n    validateKeys(object);\n\n    Object.keys(object).forEach(fieldName => {\n      if (object[fieldName] === null) {\n        return;\n      }\n      var authDataMatch = fieldName.match(/^_auth_data_([a-zA-Z0-9_]+)$/);\n      if (authDataMatch) {\n        var provider = authDataMatch[1];\n        object['authData'] = object['authData'] || {};\n        object['authData'][provider] = object[fieldName];\n        delete object[fieldName];\n        fieldName = 'authData';\n      }\n\n      columnsArray.push(fieldName);\n      if (!schema.fields[fieldName] && className === '_User') {\n        if (fieldName === '_email_verify_token' ||\n            fieldName === '_failed_login_count' ||\n            fieldName === '_perishable_token' ||\n            fieldName === '_password_history'){\n          valuesArray.push(object[fieldName]);\n        }\n\n        if (fieldName === '_email_verify_token_expires_at') {\n          if (object[fieldName]) {\n            valuesArray.push(object[fieldName].iso);\n          } else {\n            valuesArray.push(null);\n          }\n        }\n\n        if (fieldName === '_account_lockout_expires_at' ||\n            fieldName === '_perishable_token_expires_at' ||\n            fieldName === '_password_changed_at') {\n          if (object[fieldName]) {\n            valuesArray.push(object[fieldName].iso);\n          } else {\n            valuesArray.push(null);\n          }\n        }\n        return;\n      }\n      switch (schema.fields[fieldName].type) {\n      case 'Date':\n        if (object[fieldName]) {\n          valuesArray.push(object[fieldName].iso);\n        } else {\n          valuesArray.push(null);\n        }\n        break;\n      case 'Pointer':\n        valuesArray.push(object[fieldName].objectId);\n        break;\n      case 'Array':\n        if (['_rperm', '_wperm'].indexOf(fieldName) >= 0) {\n          valuesArray.push(object[fieldName]);\n        } else {\n          valuesArray.push(JSON.stringify(object[fieldName]));\n        }\n        break;\n      case 'Object':\n      case 'Bytes':\n      case 'String':\n      case 'Number':\n      case 'Boolean':\n        valuesArray.push(object[fieldName]);\n        break;\n      case 'File':\n        valuesArray.push(object[fieldName].name);\n        break;\n      case 'Polygon': {\n        const value = convertPolygonToSQL(object[fieldName].coordinates);\n        valuesArray.push(value);\n        break;\n      }\n      case 'GeoPoint':\n        // pop the point and process later\n        geoPoints[fieldName] = object[fieldName];\n        columnsArray.pop();\n        break;\n      default:\n        throw `Type ${schema.fields[fieldName].type} not supported yet`;\n      }\n    });\n\n    columnsArray = columnsArray.concat(Object.keys(geoPoints));\n    const initialValues = valuesArray.map((val, index) => {\n      let termination = '';\n      const fieldName = columnsArray[index];\n      if (['_rperm','_wperm'].indexOf(fieldName) >= 0) {\n        termination = '::text[]';\n      } else if (schema.fields[fieldName] && schema.fields[fieldName].type === 'Array') {\n        termination = '::jsonb';\n      }\n      return `$${index + 2 + columnsArray.length}${termination}`;\n    });\n    const geoPointsInjects = Object.keys(geoPoints).map((key) => {\n      const value = geoPoints[key];\n      valuesArray.push(value.longitude, value.latitude);\n      const l = valuesArray.length + columnsArray.length;\n      return `POINT($${l}, $${l + 1})`;\n    });\n\n    const columnsPattern = columnsArray.map((col, index) => `$${index + 2}:name`).join();\n    const valuesPattern = initialValues.concat(geoPointsInjects).join()\n\n    const qs = `INSERT INTO $1:name (${columnsPattern}) VALUES (${valuesPattern})`\n    const values = [className, ...columnsArray, ...valuesArray]\n    debug(qs, values);\n    return this._client.none(qs, values)\n      .then(() => ({ ops: [object] }))\n      .catch(error => {\n        if (error.code === PostgresUniqueIndexViolationError) {\n          const err = new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          err.underlyingError = error;\n          if (error.constraint) {\n            const matches = error.constraint.match(/unique_([a-zA-Z]+)/);\n            if (matches && Array.isArray(matches)) {\n              err.userInfo = { duplicated_field: matches[1] };\n            }\n          }\n          error = err;\n        }\n        throw error;\n      });\n  }\n\n  // Remove all objects that match the given Parse Query.\n  // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.\n  // If there is some other error, reject with INTERNAL_SERVER_ERROR.\n  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {\n    debug('deleteObjectsByQuery', className, query);\n    const values = [className];\n    const index = 2;\n    const where = buildWhereClause({ schema, index, query })\n    values.push(...where.values);\n    if (Object.keys(query).length === 0) {\n      where.pattern = 'TRUE';\n    }\n    const qs = `WITH deleted AS (DELETE FROM $1:name WHERE ${where.pattern} RETURNING *) SELECT count(*) FROM deleted`;\n    debug(qs, values);\n    return this._client.one(qs, values , a => +a.count)\n      .then(count => {\n        if (count === 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        } else {\n          return count;\n        }\n      })\n      .catch(error => {\n        if (error.code !== PostgresRelationDoesNotExistError) {\n          throw error;\n        }\n        // ELSE: Don't delete anything if doesn't exist\n      });\n  }\n  // Return value not currently well specified.\n  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any): Promise<any> {\n    debug('findOneAndUpdate', className, query, update);\n    return this.updateObjectsByQuery(className, schema, query, update)\n      .then((val) => val[0]);\n  }\n\n  // Apply the update to all objects that match the given Parse Query.\n  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any): Promise<[any]> {\n    debug('updateObjectsByQuery', className, query, update);\n    const updatePatterns = [];\n    const values = [className]\n    let index = 2;\n    schema = toPostgresSchema(schema);\n\n    const originalUpdate = {...update};\n    update = handleDotFields(update);\n    // Resolve authData first,\n    // So we don't end up with multiple key updates\n    for (const fieldName in update) {\n      const authDataMatch = fieldName.match(/^_auth_data_([a-zA-Z0-9_]+)$/);\n      if (authDataMatch) {\n        var provider = authDataMatch[1];\n        const value = update[fieldName];\n        delete update[fieldName];\n        update['authData'] = update['authData'] || {};\n        update['authData'][provider] = value;\n      }\n    }\n\n    for (const fieldName in update) {\n      const fieldValue = update[fieldName];\n      if (fieldValue === null) {\n        updatePatterns.push(`$${index}:name = NULL`);\n        values.push(fieldName);\n        index += 1;\n      } else if (fieldName == 'authData') {\n        // This recursively sets the json_object\n        // Only 1 level deep\n        const generate = (jsonb: string, key: string, value: any) => {\n          return `json_object_set_key(COALESCE(${jsonb}, '{}'::jsonb), ${key}, ${value})::jsonb`;\n        }\n        const lastKey = `$${index}:name`;\n        const fieldNameIndex = index;\n        index += 1;\n        values.push(fieldName);\n        const update = Object.keys(fieldValue).reduce((lastKey: string, key: string) => {\n          const str = generate(lastKey, `$${index}::text`, `$${index + 1}::jsonb`)\n          index += 2;\n          let value = fieldValue[key];\n          if (value) {\n            if (value.__op === 'Delete') {\n              value = null;\n            } else {\n              value = JSON.stringify(value)\n            }\n          }\n          values.push(key, value);\n          return str;\n        }, lastKey);\n        updatePatterns.push(`$${fieldNameIndex}:name = ${update}`);\n      } else if (fieldValue.__op === 'Increment') {\n        updatePatterns.push(`$${index}:name = COALESCE($${index}:name, 0) + $${index + 1}`);\n        values.push(fieldName, fieldValue.amount);\n        index += 2;\n      } else if (fieldValue.__op === 'Add') {\n        updatePatterns.push(`$${index}:name = array_add(COALESCE($${index}:name, '[]'::jsonb), $${index + 1}::jsonb)`);\n        values.push(fieldName, JSON.stringify(fieldValue.objects));\n        index += 2;\n      } else if (fieldValue.__op === 'Delete') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`)\n        values.push(fieldName, null);\n        index += 2;\n      } else if (fieldValue.__op === 'Remove') {\n        updatePatterns.push(`$${index}:name = array_remove(COALESCE($${index}:name, '[]'::jsonb), $${index + 1}::jsonb)`)\n        values.push(fieldName, JSON.stringify(fieldValue.objects));\n        index += 2;\n      } else if (fieldValue.__op === 'AddUnique') {\n        updatePatterns.push(`$${index}:name = array_add_unique(COALESCE($${index}:name, '[]'::jsonb), $${index + 1}::jsonb)`);\n        values.push(fieldName, JSON.stringify(fieldValue.objects));\n        index += 2;\n      } else if (fieldName === 'updatedAt') { //TODO: stop special casing this. It should check for __type === 'Date' and use .iso\n        updatePatterns.push(`$${index}:name = $${index + 1}`)\n        values.push(fieldName, fieldValue);\n        index += 2;\n      } else if (typeof fieldValue === 'string') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue);\n        index += 2;\n      } else if (typeof fieldValue === 'boolean') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue);\n        index += 2;\n      } else if (fieldValue.__type === 'Pointer') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue.objectId);\n        index += 2;\n      } else if (fieldValue.__type === 'Date') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, toPostgresValue(fieldValue));\n        index += 2;\n      } else if (fieldValue instanceof Date) {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue);\n        index += 2;\n      } else if (fieldValue.__type === 'File') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, toPostgresValue(fieldValue));\n        index += 2;\n      } else if (fieldValue.__type === 'GeoPoint') {\n        updatePatterns.push(`$${index}:name = POINT($${index + 1}, $${index + 2})`);\n        values.push(fieldName, fieldValue.longitude, fieldValue.latitude);\n        index += 3;\n      } else if (fieldValue.__type === 'Polygon') {\n        const value = convertPolygonToSQL(fieldValue.coordinates);\n        updatePatterns.push(`$${index}:name = $${index + 1}::polygon`);\n        values.push(fieldName, value);\n        index += 2;\n      } else if (fieldValue.__type === 'Relation') {\n        // noop\n      } else if (typeof fieldValue === 'number') {\n        updatePatterns.push(`$${index}:name = $${index + 1}`);\n        values.push(fieldName, fieldValue);\n        index += 2;\n      } else if (typeof fieldValue === 'object'\n                    && schema.fields[fieldName]\n                    && schema.fields[fieldName].type === 'Object') {\n        // Gather keys to increment\n        const keysToIncrement = Object.keys(originalUpdate).filter(k => {\n          // choose top level fields that have a delete operation set\n          // Note that Object.keys is iterating over the **original** update object\n          // and that some of the keys of the original update could be null or undefined:\n          // (See the above check `if (fieldValue === null || typeof fieldValue == \"undefined\")`)\n          const value = originalUpdate[k];\n          return value && value.__op === 'Increment' && k.split('.').length === 2 && k.split(\".\")[0] === fieldName;\n        }).map(k => k.split('.')[1]);\n\n        let incrementPatterns = '';\n        if (keysToIncrement.length > 0) {\n          incrementPatterns = ' || ' + keysToIncrement.map((c) => {\n            const amount = fieldValue[c].amount;\n            return `CONCAT('{\"${c}\":', COALESCE($${index}:name->>'${c}','0')::int + ${amount}, '}')::jsonb`;\n          }).join(' || ');\n          // Strip the keys\n          keysToIncrement.forEach((key) => {\n            delete fieldValue[key];\n          });\n        }\n\n        const keysToDelete: Array<string> = Object.keys(originalUpdate).filter(k => {\n          // choose top level fields that have a delete operation set.\n          const value = originalUpdate[k];\n          return value && value.__op === 'Delete' && k.split('.').length === 2 && k.split(\".\")[0] === fieldName;\n        }).map(k => k.split('.')[1]);\n\n        const deletePatterns = keysToDelete.reduce((p: string, c: string, i: number) => {\n          return p + ` - '$${index + 1 + i}:value'`;\n        }, '');\n\n        updatePatterns.push(`$${index}:name = ('{}'::jsonb ${deletePatterns} ${incrementPatterns} || $${index + 1 + keysToDelete.length}::jsonb )`);\n\n        values.push(fieldName, ...keysToDelete, JSON.stringify(fieldValue));\n        index += 2 + keysToDelete.length;\n      } else if (Array.isArray(fieldValue)\n                    && schema.fields[fieldName]\n                    && schema.fields[fieldName].type === 'Array') {\n        const expectedType = parseTypeToPostgresType(schema.fields[fieldName]);\n        if (expectedType === 'text[]') {\n          updatePatterns.push(`$${index}:name = $${index + 1}::text[]`);\n        } else {\n          let type = 'text';\n          for (const elt of fieldValue) {\n            if (typeof elt == 'object') {\n              type = 'json';\n              break;\n            }\n          }\n          updatePatterns.push(`$${index}:name = array_to_json($${index + 1}::${type}[])::jsonb`);\n        }\n        values.push(fieldName, fieldValue);\n        index += 2;\n      } else {\n        debug('Not supported update', fieldName, fieldValue);\n        return Promise.reject(new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, `Postgres doesn't support update ${JSON.stringify(fieldValue)} yet`));\n      }\n    }\n\n    const where = buildWhereClause({ schema, index, query })\n    values.push(...where.values);\n\n    const whereClause = where.pattern.length > 0 ? `WHERE ${where.pattern}` : '';\n    const qs = `UPDATE $1:name SET ${updatePatterns.join()} ${whereClause} RETURNING *`;\n    debug('update: ', qs, values);\n    return this._client.any(qs, values);\n  }\n\n  // Hopefully, we can get rid of this. It's only used for config and hooks.\n  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {\n    debug('upsertOneObject', {className, query, update});\n    const createValue = Object.assign({}, query, update);\n    return this.createObject(className, schema, createValue)\n      .catch(error => {\n        // ignore duplicate value errors as it's upsert\n        if (error.code !== Parse.Error.DUPLICATE_VALUE) {\n          throw error;\n        }\n        return this.findOneAndUpdate(className, schema, query, update);\n      });\n  }\n\n  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys }: QueryOptions) {\n    debug('find', className, query, {skip, limit, sort, keys });\n    const hasLimit = limit !== undefined;\n    const hasSkip = skip !== undefined;\n    let values = [className];\n    const where = buildWhereClause({ schema, query, index: 2 })\n    values.push(...where.values);\n\n    const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : '';\n    const limitPattern = hasLimit ? `LIMIT $${values.length + 1}` : '';\n    if (hasLimit) {\n      values.push(limit);\n    }\n    const skipPattern = hasSkip ? `OFFSET $${values.length + 1}` : '';\n    if (hasSkip) {\n      values.push(skip);\n    }\n\n    let sortPattern = '';\n    if (sort) {\n      const sortCopy: any = sort;\n      const sorting = Object.keys(sort).map((key) => {\n        const transformKey = transformDotFieldToComponents(key).join('->');\n        // Using $idx pattern gives:  non-integer constant in ORDER BY\n        if (sortCopy[key] === 1) {\n          return `${transformKey} ASC`;\n        }\n        return `${transformKey} DESC`;\n      }).join();\n      sortPattern = sort !== undefined && Object.keys(sort).length > 0 ? `ORDER BY ${sorting}` : '';\n    }\n    if (where.sorts && Object.keys((where.sorts: any)).length > 0) {\n      sortPattern = `ORDER BY ${where.sorts.join()}`;\n    }\n\n    let columns = '*';\n    if (keys) {\n      // Exclude empty keys\n      keys = keys.filter((key) => {\n        return key.length > 0;\n      });\n      columns = keys.map((key, index) => {\n        if (key === '$score') {\n          return `ts_rank_cd(to_tsvector($${2}, $${3}:name), to_tsquery($${4}, $${5}), 32) as score`;\n        }\n        return `$${index + values.length + 1}:name`;\n      }).join();\n      values = values.concat(keys);\n    }\n\n    const qs = `SELECT ${columns} FROM $1:name ${wherePattern} ${sortPattern} ${limitPattern} ${skipPattern}`;\n    debug(qs, values);\n    return this._client.any(qs, values)\n      .catch(error => {\n        // Query on non existing table, don't crash\n        if (error.code !== PostgresRelationDoesNotExistError) {\n          throw error;\n        }\n        return [];\n      })\n      .then(results => results.map(object => this.postgresObjectToParseObject(className, object, schema)));\n  }\n\n  // Converts from a postgres-format object to a REST-format object.\n  // Does not strip out anything based on a lack of authentication.\n  postgresObjectToParseObject(className: string, object: any, schema: any) {\n    Object.keys(schema.fields).forEach(fieldName => {\n      if (schema.fields[fieldName].type === 'Pointer' && object[fieldName]) {\n        object[fieldName] = { objectId: object[fieldName], __type: 'Pointer', className: schema.fields[fieldName].targetClass };\n      }\n      if (schema.fields[fieldName].type === 'Relation') {\n        object[fieldName] = {\n          __type: \"Relation\",\n          className: schema.fields[fieldName].targetClass\n        }\n      }\n      if (object[fieldName] && schema.fields[fieldName].type === 'GeoPoint') {\n        object[fieldName] = {\n          __type: \"GeoPoint\",\n          latitude: object[fieldName].y,\n          longitude: object[fieldName].x\n        }\n      }\n      if (object[fieldName] && schema.fields[fieldName].type === 'Polygon') {\n        let coords = object[fieldName];\n        coords = coords.substr(2, coords.length - 4).split('),(');\n        coords = coords.map((point) => {\n          return [\n            parseFloat(point.split(',')[1]),\n            parseFloat(point.split(',')[0])\n          ];\n        });\n        object[fieldName] = {\n          __type: \"Polygon\",\n          coordinates: coords\n        }\n      }\n      if (object[fieldName] && schema.fields[fieldName].type === 'File') {\n        object[fieldName] = {\n          __type: 'File',\n          name: object[fieldName]\n        }\n      }\n    });\n    //TODO: remove this reliance on the mongo format. DB adapter shouldn't know there is a difference between created at and any other date field.\n    if (object.createdAt) {\n      object.createdAt = object.createdAt.toISOString();\n    }\n    if (object.updatedAt) {\n      object.updatedAt = object.updatedAt.toISOString();\n    }\n    if (object.expiresAt) {\n      object.expiresAt = { __type: 'Date', iso: object.expiresAt.toISOString() };\n    }\n    if (object._email_verify_token_expires_at) {\n      object._email_verify_token_expires_at = { __type: 'Date', iso: object._email_verify_token_expires_at.toISOString() };\n    }\n    if (object._account_lockout_expires_at) {\n      object._account_lockout_expires_at = { __type: 'Date', iso: object._account_lockout_expires_at.toISOString() };\n    }\n    if (object._perishable_token_expires_at) {\n      object._perishable_token_expires_at = { __type: 'Date', iso: object._perishable_token_expires_at.toISOString() };\n    }\n    if (object._password_changed_at) {\n      object._password_changed_at = { __type: 'Date', iso: object._password_changed_at.toISOString() };\n    }\n\n    for (const fieldName in object) {\n      if (object[fieldName] === null) {\n        delete object[fieldName];\n      }\n      if (object[fieldName] instanceof Date) {\n        object[fieldName] = { __type: 'Date', iso: object[fieldName].toISOString() };\n      }\n    }\n\n    return object;\n  }\n\n  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't\n  // currently know which fields are nullable and which aren't, we ignore that criteria.\n  // As such, we shouldn't expose this function to users of parse until we have an out-of-band\n  // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,\n  // which is why we use sparse indexes.\n  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {\n    // Use the same name for every ensureUniqueness attempt, because postgres\n    // Will happily create the same index with multiple names.\n    const constraintName = `unique_${fieldNames.sort().join('_')}`;\n    const constraintPatterns = fieldNames.map((fieldName, index) => `$${index + 3}:name`);\n    const qs = `ALTER TABLE $1:name ADD CONSTRAINT $2:name UNIQUE (${constraintPatterns.join()})`;\n    return this._client.none(qs, [className, constraintName, ...fieldNames])\n      .catch(error => {\n        if (error.code === PostgresDuplicateRelationError && error.message.includes(constraintName)) {\n        // Index already exists. Ignore error.\n        } else if (error.code === PostgresUniqueIndexViolationError && error.message.includes(constraintName)) {\n        // Cast the error into the proper parse error\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n        } else {\n          throw error;\n        }\n      });\n  }\n\n  // Executes a count.\n  count(className: string, schema: SchemaType, query: QueryType) {\n    debug('count', className, query);\n    const values = [className];\n    const where = buildWhereClause({ schema, query, index: 2 });\n    values.push(...where.values);\n\n    const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : '';\n    const qs = `SELECT count(*) FROM $1:name ${wherePattern}`;\n    return this._client.one(qs, values, a => +a.count)\n      .catch(error => {\n        if (error.code !== PostgresRelationDoesNotExistError) {\n          throw error;\n        }\n        return 0;\n      });\n  }\n\n  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {\n    debug('distinct', className, query);\n    let field = fieldName;\n    let column = fieldName;\n    const isNested = fieldName.indexOf('.') >= 0;\n    if (isNested) {\n      field = transformDotFieldToComponents(fieldName).join('->');\n      column = fieldName.split('.')[0];\n    }\n    const isArrayField = schema.fields\n          && schema.fields[fieldName]\n          && schema.fields[fieldName].type === 'Array';\n    const isPointerField = schema.fields\n          && schema.fields[fieldName]\n          && schema.fields[fieldName].type === 'Pointer';\n    const values = [field, column, className];\n    const where = buildWhereClause({ schema, query, index: 4 });\n    values.push(...where.values);\n\n    const wherePattern = where.pattern.length > 0 ? `WHERE ${where.pattern}` : '';\n    const transformer = isArrayField ? 'jsonb_array_elements' : 'ON';\n    let qs = `SELECT DISTINCT ${transformer}($1:name) $2:name FROM $3:name ${wherePattern}`;\n    if (isNested) {\n      qs = `SELECT DISTINCT ${transformer}($1:raw) $2:raw FROM $3:name ${wherePattern}`;\n    }\n    debug(qs, values);\n    return this._client.any(qs, values)\n      .catch((error) => {\n        if (error.code === PostgresMissingColumnError) {\n          return [];\n        }\n        throw error;\n      })\n      .then((results) => {\n        if (!isNested) {\n          results = results.filter((object) => object[field] !== null);\n          return results.map(object => {\n            if (!isPointerField) {\n              return object[field];\n            }\n            return {\n              __type: 'Pointer',\n              className:  schema.fields[fieldName].targetClass,\n              objectId: object[field]\n            };\n          });\n        }\n        const child = fieldName.split('.')[1];\n        return results.map(object => object[column][child]);\n      })\n      .then(results => results.map(object => this.postgresObjectToParseObject(className, object, schema)));\n  }\n\n  aggregate(className: string, schema: any, pipeline: any) {\n    debug('aggregate', className, pipeline);\n    const values = [className];\n    let index: number = 2;\n    let columns: string[] = [];\n    let countField = null;\n    let groupValues = null;\n    let wherePattern = '';\n    let limitPattern = '';\n    let skipPattern = '';\n    let sortPattern = '';\n    let groupPattern = '';\n    for (let i = 0; i < pipeline.length; i += 1) {\n      const stage = pipeline[i];\n      if (stage.$group) {\n        for (const field in stage.$group) {\n          const value = stage.$group[field];\n          if (value === null || value === undefined) {\n            continue;\n          }\n          if (field === '_id' && (typeof value === 'string') && value !== '') {\n            columns.push(`$${index}:name AS \"objectId\"`);\n            groupPattern = `GROUP BY $${index}:name`;\n            values.push(transformAggregateField(value));\n            index += 1;\n            continue;\n          }\n          if (field === '_id' && (typeof value === 'object') && Object.keys(value).length !== 0) {\n            groupValues = value;\n            const groupByFields = [];\n            for (const alias in value) {\n              const operation = Object.keys(value[alias])[0];\n              const source = transformAggregateField(value[alias][operation]);\n              if (mongoAggregateToPostgres[operation]) {\n                if (!groupByFields.includes(`\"${source}\"`)) {\n                  groupByFields.push(`\"${source}\"`);\n                }\n                columns.push(`EXTRACT(${mongoAggregateToPostgres[operation]} FROM $${index}:name AT TIME ZONE 'UTC') AS $${index + 1}:name`);\n                values.push(source, alias);\n                index += 2;\n              }\n            }\n            groupPattern = `GROUP BY $${index}:raw`;\n            values.push(groupByFields.join());\n            index += 1;\n            continue;\n          }\n          if (value.$sum) {\n            if (typeof value.$sum === 'string') {\n              columns.push(`SUM($${index}:name) AS $${index + 1}:name`);\n              values.push(transformAggregateField(value.$sum), field);\n              index += 2;\n            } else {\n              countField = field;\n              columns.push(`COUNT(*) AS $${index}:name`);\n              values.push(field);\n              index += 1;\n            }\n          }\n          if (value.$max) {\n            columns.push(`MAX($${index}:name) AS $${index + 1}:name`);\n            values.push(transformAggregateField(value.$max), field);\n            index += 2;\n          }\n          if (value.$min) {\n            columns.push(`MIN($${index}:name) AS $${index + 1}:name`);\n            values.push(transformAggregateField(value.$min), field);\n            index += 2;\n          }\n          if (value.$avg) {\n            columns.push(`AVG($${index}:name) AS $${index + 1}:name`);\n            values.push(transformAggregateField(value.$avg), field);\n            index += 2;\n          }\n        }\n      } else {\n        columns.push('*');\n      }\n      if (stage.$project) {\n        if (columns.includes('*')) {\n          columns = [];\n        }\n        for (const field in stage.$project) {\n          const value = stage.$project[field];\n          if ((value === 1 || value === true)) {\n            columns.push(`$${index}:name`);\n            values.push(field);\n            index += 1;\n          }\n        }\n      }\n      if (stage.$match) {\n        const patterns = [];\n        const orOrAnd = stage.$match.hasOwnProperty('$or') ? ' OR ' : ' AND ';\n\n        if (stage.$match.$or) {\n          const collapse = {};\n          stage.$match.$or.forEach((element) => {\n            for (const key in element) {\n              collapse[key] = element[key];\n            }\n          });\n          stage.$match = collapse;\n        }\n        for (const field in stage.$match) {\n          const value = stage.$match[field];\n          const matchPatterns = [];\n          Object.keys(ParseToPosgresComparator).forEach((cmp) => {\n            if (value[cmp]) {\n              const pgComparator = ParseToPosgresComparator[cmp];\n              matchPatterns.push(`$${index}:name ${pgComparator} $${index + 1}`);\n              values.push(field, toPostgresValue(value[cmp]));\n              index += 2;\n            }\n          });\n          if (matchPatterns.length > 0) {\n            patterns.push(`(${matchPatterns.join(' AND ')})`);\n          }\n          if (schema.fields[field] && schema.fields[field].type && matchPatterns.length === 0) {\n            patterns.push(`$${index}:name = $${index + 1}`);\n            values.push(field, value);\n            index += 2;\n          }\n        }\n        wherePattern = patterns.length > 0 ? `WHERE ${patterns.join(` ${orOrAnd} `)}` : '';\n      }\n      if (stage.$limit) {\n        limitPattern = `LIMIT $${index}`;\n        values.push(stage.$limit);\n        index += 1;\n      }\n      if (stage.$skip) {\n        skipPattern = `OFFSET $${index}`;\n        values.push(stage.$skip);\n        index += 1;\n      }\n      if (stage.$sort) {\n        const sort = stage.$sort;\n        const keys = Object.keys(sort);\n        const sorting = keys.map((key) => {\n          const transformer = sort[key] === 1 ? 'ASC' : 'DESC';\n          const order = `$${index}:name ${transformer}`;\n          index += 1;\n          return order;\n        }).join();\n        values.push(...keys);\n        sortPattern = sort !== undefined && sorting.length > 0 ? `ORDER BY ${sorting}` : '';\n      }\n    }\n\n    const qs = `SELECT ${columns.join()} FROM $1:name ${wherePattern} ${sortPattern} ${limitPattern} ${skipPattern} ${groupPattern}`;\n    debug(qs, values);\n    return this._client.map(qs, values, a => this.postgresObjectToParseObject(className, a, schema))\n      .then(results => {\n        results.forEach(result => {\n          if (!result.hasOwnProperty('objectId')) {\n            result.objectId = null;\n          }\n          if (groupValues) {\n            result.objectId = {};\n            for (const key in groupValues) {\n              result.objectId[key] = result[key];\n              delete result[key];\n            }\n          }\n          if (countField) {\n            result[countField] = parseInt(result[countField], 10);\n          }\n        });\n        return results;\n      });\n  }\n\n  performInitialization({ VolatileClassesSchemas }: any) {\n    // TODO: This method needs to be rewritten to make proper use of connections (@vitaly-t)\n    debug('performInitialization');\n    const promises = VolatileClassesSchemas.map((schema) => {\n      return this.createTable(schema.className, schema)\n        .catch((err) => {\n          if (err.code === PostgresDuplicateRelationError || err.code === Parse.Error.INVALID_CLASS_NAME) {\n            return Promise.resolve();\n          }\n          throw err;\n        })\n        .then(() => this.schemaUpgrade(schema.className, schema));\n    });\n    return Promise.all(promises)\n      .then(() => {\n        return this._client.tx('perform-initialization', t => {\n          return t.batch([\n            t.none(sql.misc.jsonObjectSetKeys),\n            t.none(sql.array.add),\n            t.none(sql.array.addUnique),\n            t.none(sql.array.remove),\n            t.none(sql.array.containsAll),\n            t.none(sql.array.containsAllRegex),\n            t.none(sql.array.contains)\n          ]);\n        });\n      })\n      .then(data => {\n        debug(`initializationDone in ${data.duration}`);\n      })\n      .catch(error => {\n        /* eslint-disable no-console */\n        console.error(error);\n      });\n  }\n\n  createIndexes(className: string, indexes: any, conn: ?any): Promise<void> {\n    return (conn || this._client).tx(t => t.batch(indexes.map(i => {\n      return t.none('CREATE INDEX $1:name ON $2:name ($3:name)', [i.name, className, i.key]);\n    })));\n  }\n\n  createIndexesIfNeeded(className: string, fieldName: string, type: any, conn: ?any): Promise<void> {\n    return (conn || this._client).none('CREATE INDEX $1:name ON $2:name ($3:name)', [fieldName, className, type]);\n  }\n\n  dropIndexes(className: string, indexes: any, conn: any): Promise<void> {\n    const queries = indexes.map(i => ({query: 'DROP INDEX $1:name', values: i}));\n    return (conn || this._client).tx(t => t.none(this._pgp.helpers.concat(queries)));\n  }\n\n  getIndexes(className: string) {\n    const qs = 'SELECT * FROM pg_indexes WHERE tablename = ${className}';\n    return this._client.any(qs, {className});\n  }\n\n  updateSchemaWithIndexes(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n\nfunction convertPolygonToSQL(polygon) {\n  if (polygon.length < 3) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_JSON,\n      `Polygon must have at least 3 values`\n    );\n  }\n  if (polygon[0][0] !== polygon[polygon.length - 1][0] ||\n    polygon[0][1] !== polygon[polygon.length - 1][1]) {\n    polygon.push(polygon[0]);\n  }\n  const unique = polygon.filter((item, index, ar) => {\n    let foundIndex = -1;\n    for (let i = 0; i < ar.length; i += 1) {\n      const pt = ar[i];\n      if (pt[0] === item[0] &&\n          pt[1] === item[1]) {\n        foundIndex = i;\n        break;\n      }\n    }\n    return foundIndex === index;\n  });\n  if (unique.length < 3) {\n    throw new Parse.Error(\n      Parse.Error.INTERNAL_SERVER_ERROR,\n      'GeoJSON: Loop must have at least 3 different vertices'\n    );\n  }\n  const points = polygon.map((point) => {\n    Parse.GeoPoint._validate(parseFloat(point[1]), parseFloat(point[0]));\n    return `(${point[1]}, ${point[0]})`;\n  }).join(', ');\n  return `(${points})`;\n}\n\nfunction removeWhiteSpace(regex) {\n  if (!regex.endsWith('\\n')){\n    regex += '\\n';\n  }\n\n  // remove non escaped comments\n  return regex.replace(/([^\\\\])#.*\\n/gmi, '$1')\n    // remove lines starting with a comment\n    .replace(/^#.*\\n/gmi, '')\n    // remove non escaped whitespace\n    .replace(/([^\\\\])\\s+/gmi, '$1')\n    // remove whitespace at the beginning of a line\n    .replace(/^\\s+/, '')\n    .trim();\n}\n\nfunction processRegexPattern(s) {\n  if (s && s.startsWith('^')){\n    // regex for startsWith\n    return '^' + literalizeRegexPart(s.slice(1));\n\n  } else if (s && s.endsWith('$')) {\n    // regex for endsWith\n    return literalizeRegexPart(s.slice(0, s.length - 1)) + '$';\n  }\n\n  // regex for contains\n  return literalizeRegexPart(s);\n}\n\nfunction isStartsWithRegex(value) {\n  if (!value || typeof value !== 'string' || !value.startsWith('^')) {\n    return false;\n  }\n\n  const matches = value.match(/\\^\\\\Q.*\\\\E/);\n  return !!matches;\n}\n\nfunction isAllValuesRegexOrNone(values) {\n  if (!values || !Array.isArray(values) || values.length === 0) {\n    return true;\n  }\n\n  const firstValuesIsRegex = isStartsWithRegex(values[0].$regex);\n  if (values.length === 1) {\n    return firstValuesIsRegex;\n  }\n\n  for (let i = 1, length = values.length; i < length; ++i) {\n    if (firstValuesIsRegex !== isStartsWithRegex(values[i].$regex)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isAnyValueRegexStartsWith(values) {\n  return values.some(function (value) {\n    return isStartsWithRegex(value.$regex);\n  });\n}\n\nfunction createLiteralRegex(remaining) {\n  return remaining.split('').map(c => {\n    if (c.match(/[0-9a-zA-Z]/) !== null) {\n      // don't escape alphanumeric characters\n      return c;\n    }\n    // escape everything else (single quotes with single quotes, everything else with a backslash)\n    return c === `'` ? `''` : `\\\\${c}`;\n  }).join('');\n}\n\nfunction literalizeRegexPart(s: string) {\n  const matcher1 = /\\\\Q((?!\\\\E).*)\\\\E$/\n  const result1: any = s.match(matcher1);\n  if(result1 && result1.length > 1 && result1.index > -1) {\n    // process regex that has a beginning and an end specified for the literal text\n    const prefix = s.substr(0, result1.index);\n    const remaining = result1[1];\n\n    return literalizeRegexPart(prefix) + createLiteralRegex(remaining);\n  }\n\n  // process regex that has a beginning specified for the literal text\n  const matcher2 = /\\\\Q((?!\\\\E).*)$/\n  const result2: any = s.match(matcher2);\n  if(result2 && result2.length > 1 && result2.index > -1){\n    const prefix = s.substr(0, result2.index);\n    const remaining = result2[1];\n\n    return literalizeRegexPart(prefix) + createLiteralRegex(remaining);\n  }\n\n  // remove all instances of \\Q and \\E from the remaining text & escape single quotes\n  return (\n    s.replace(/([^\\\\])(\\\\E)/, '$1')\n      .replace(/([^\\\\])(\\\\Q)/, '$1')\n      .replace(/^\\\\E/, '')\n      .replace(/^\\\\Q/, '')\n      .replace(/([^'])'/, `$1''`)\n      .replace(/^'([^'])/, `''$1`)\n  );\n}\n\nvar GeoPointCoder = {\n  isValidJSON(value) {\n    return (typeof value === 'object' &&\n      value !== null &&\n      value.__type === 'GeoPoint'\n    );\n  }\n};\n\nexport default PostgresStorageAdapter;\n"]} \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql b/lib/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql new file mode 100644 index 0000000000..7ca5853a9f --- /dev/null +++ b/lib/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql @@ -0,0 +1,14 @@ +CREATE OR REPLACE FUNCTION array_contains_all_regex( + "array" jsonb, + "values" jsonb +) + RETURNS boolean + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT CASE + WHEN 0 = jsonb_array_length("values") THEN true = false + ELSE (SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements_text("array") as elt WHERE elt LIKE ANY (SELECT jsonb_array_elements_text("values"))) as RES) + END; +$function$; \ No newline at end of file diff --git a/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql b/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql index 24355bc732..8db1ca0e7b 100644 --- a/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql +++ b/lib/Adapters/Storage/Postgres/sql/array/contains-all.sql @@ -7,5 +7,8 @@ CREATE OR REPLACE FUNCTION array_contains_all( IMMUTABLE STRICT AS $function$ - SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements("array") as elt WHERE elt IN (SELECT jsonb_array_elements("values"))) as RES; + SELECT CASE + WHEN 0 = jsonb_array_length("values") THEN true = false + ELSE (SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements_text("array") as elt WHERE elt IN (SELECT jsonb_array_elements_text("values"))) as RES) + END; $function$; diff --git a/lib/Adapters/Storage/Postgres/sql/index.js b/lib/Adapters/Storage/Postgres/sql/index.js index c1b31b93ac..8774d5fbff 100644 --- a/lib/Adapters/Storage/Postgres/sql/index.js +++ b/lib/Adapters/Storage/Postgres/sql/index.js @@ -9,6 +9,7 @@ module.exports = { addUnique: sql('array/add-unique.sql'), contains: sql('array/contains.sql'), containsAll: sql('array/contains-all.sql'), + containsAllRegex: sql('array/contains-all-regex.sql'), remove: sql('array/remove.sql') }, misc: { @@ -29,4 +30,5 @@ function sql(file) { } return qf; -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Adapters/Storage/StorageAdapter.js b/lib/Adapters/Storage/StorageAdapter.js index 9a390c31f7..97297a65bc 100644 --- a/lib/Adapters/Storage/StorageAdapter.js +++ b/lib/Adapters/Storage/StorageAdapter.js @@ -1 +1,2 @@ -"use strict"; \ No newline at end of file +"use strict"; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJTdG9yYWdlQWRhcHRlci5qcyIsInNvdXJjZXNDb250ZW50IjpbXX0= \ No newline at end of file diff --git a/lib/Auth.js b/lib/Auth.js index 77d21f59dc..1905aac26b 100644 --- a/lib/Auth.js +++ b/lib/Auth.js @@ -23,14 +23,14 @@ function Auth({ config, isMaster = false, isReadOnly = false, user, installation // Whether this auth could possibly modify the given user id. // It still could be forbidden via ACLs even if this returns true. -Auth.prototype.couldUpdateUserId = function (userId) { +Auth.prototype.isUnauthenticated = function () { if (this.isMaster) { - return true; + return false; } - if (this.user && this.user.id === userId) { - return true; + if (this.user) { + return false; } - return false; + return true; }; // A helper to get a master-level Auth object @@ -65,7 +65,7 @@ var getAuthForSessionToken = function ({ config, sessionToken, installationId } return query.execute().then(response => { var results = response.results; if (results.length !== 1 || !results[0]['user']) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } var now = new Date(), @@ -254,4 +254,5 @@ module.exports = { getAuthForSessionToken, getAuthForLegacySessionToken, createSession -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Auth.js"],"names":["cryptoUtils","require","RestQuery","Parse","Auth","config","isMaster","isReadOnly","user","installationId","userRoles","fetchedRoles","rolePromise","prototype","isUnauthenticated","master","readOnly","nobody","getAuthForSessionToken","sessionToken","cacheController","get","then","userJSON","cachedUser","Object","fromJSON","Promise","resolve","restOptions","limit","include","query","execute","response","results","length","Error","INVALID_SESSION_TOKEN","now","Date","expiresAt","iso","undefined","obj","password","put","userObject","getAuthForLegacySessionToken","className","getUserRoles","_loadRoles","cacheAdapter","role","id","cachedRoles","restWhere","__type","objectId","Array","rolesMap","reduce","m","r","names","push","name","ids","_getAllRolesNamesForRoleIds","roleNames","map","roleIDs","queriedRoles","ins","filter","roleID","Set","resultMap","memo","concat","createSession","userId","createdWith","additionalSessionData","token","newToken","generateSessionExpiresAt","sessionData","restricted","_encode","assign","RestWrite","module","exports"],"mappings":"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","file":"Auth.js","sourcesContent":["const cryptoUtils = require('./cryptoUtils');\nconst RestQuery = require('./RestQuery');\nconst Parse = require('parse/node');\n\n// An Auth object tells you who is requesting something and whether\n// the master key was used.\n// userObject is a Parse.User and can be null if there's no user.\nfunction Auth({ config, isMaster = false, isReadOnly = false, user, installationId } = {}) {\n  this.config = config;\n  this.installationId = installationId;\n  this.isMaster = isMaster;\n  this.user = user;\n  this.isReadOnly = isReadOnly;\n\n  // Assuming a users roles won't change during a single request, we'll\n  // only load them once.\n  this.userRoles = [];\n  this.fetchedRoles = false;\n  this.rolePromise = null;\n}\n\n// Whether this auth could possibly modify the given user id.\n// It still could be forbidden via ACLs even if this returns true.\nAuth.prototype.isUnauthenticated = function() {\n  if (this.isMaster) {\n    return false;\n  }\n  if (this.user) {\n    return false;\n  }\n  return true;\n};\n\n// A helper to get a master-level Auth object\nfunction master(config) {\n  return new Auth({ config, isMaster: true });\n}\n\n// A helper to get a master-level Auth object\nfunction readOnly(config) {\n  return new Auth({ config, isMaster: true, isReadOnly: true });\n}\n\n// A helper to get a nobody-level Auth object\nfunction nobody(config) {\n  return new Auth({ config, isMaster: false });\n}\n\n\n// Returns a promise that resolves to an Auth object\nvar getAuthForSessionToken = function({ config, sessionToken, installationId } = {}) {\n  return config.cacheController.user.get(sessionToken).then((userJSON) => {\n    if (userJSON) {\n      const cachedUser = Parse.Object.fromJSON(userJSON);\n      return Promise.resolve(new Auth({config, isMaster: false, installationId, user: cachedUser}));\n    }\n\n    var restOptions = {\n      limit: 1,\n      include: 'user'\n    };\n\n    var query = new RestQuery(config, master(config), '_Session', {sessionToken}, restOptions);\n    return query.execute().then((response) => {\n      var results = response.results;\n      if (results.length !== 1 || !results[0]['user']) {\n        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n      }\n\n      var now = new Date(),\n        expiresAt = results[0].expiresAt ? new Date(results[0].expiresAt.iso) : undefined;\n      if (expiresAt < now) {\n        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,\n          'Session token is expired.');\n      }\n      var obj = results[0]['user'];\n      delete obj.password;\n      obj['className'] = '_User';\n      obj['sessionToken'] = sessionToken;\n      config.cacheController.user.put(sessionToken, obj);\n      const userObject = Parse.Object.fromJSON(obj);\n      return new Auth({config, isMaster: false, installationId, user: userObject});\n    });\n  });\n};\n\nvar getAuthForLegacySessionToken = function({config, sessionToken, installationId } = {}) {\n  var restOptions = {\n    limit: 1\n  };\n  var query = new RestQuery(config, master(config), '_User', { sessionToken: sessionToken}, restOptions);\n  return query.execute().then((response) => {\n    var results = response.results;\n    if (results.length !== 1) {\n      throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid legacy session token');\n    }\n    const obj = results[0];\n    obj.className = '_User';\n    const userObject = Parse.Object.fromJSON(obj);\n    return new Auth({config, isMaster: false, installationId, user: userObject});\n  });\n}\n\n// Returns a promise that resolves to an array of role names\nAuth.prototype.getUserRoles = function() {\n  if (this.isMaster || !this.user) {\n    return Promise.resolve([]);\n  }\n  if (this.fetchedRoles) {\n    return Promise.resolve(this.userRoles);\n  }\n  if (this.rolePromise) {\n    return this.rolePromise;\n  }\n  this.rolePromise = this._loadRoles();\n  return this.rolePromise;\n};\n\n// Iterates through the role tree and compiles a users roles\nAuth.prototype._loadRoles = function() {\n  var cacheAdapter = this.config.cacheController;\n  return cacheAdapter.role.get(this.user.id).then((cachedRoles) => {\n    if (cachedRoles != null) {\n      this.fetchedRoles = true;\n      this.userRoles = cachedRoles;\n      return Promise.resolve(cachedRoles);\n    }\n\n    var restWhere = {\n      'users': {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: this.user.id\n      }\n    };\n    // First get the role ids this user is directly a member of\n    var query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});\n    return query.execute().then((response) => {\n      var results = response.results;\n      if (!results.length) {\n        this.userRoles = [];\n        this.fetchedRoles = true;\n        this.rolePromise = null;\n\n        cacheAdapter.role.put(this.user.id, Array(...this.userRoles));\n        return Promise.resolve(this.userRoles);\n      }\n      var rolesMap = results.reduce((m, r) => {\n        m.names.push(r.name);\n        m.ids.push(r.objectId);\n        return m;\n      }, {ids: [], names: []});\n\n      // run the recursive finding\n      return this._getAllRolesNamesForRoleIds(rolesMap.ids, rolesMap.names)\n        .then((roleNames) => {\n          this.userRoles = roleNames.map((r) => {\n            return 'role:' + r;\n          });\n          this.fetchedRoles = true;\n          this.rolePromise = null;\n          cacheAdapter.role.put(this.user.id, Array(...this.userRoles));\n          return Promise.resolve(this.userRoles);\n        });\n    });\n  });\n};\n\n// Given a list of roleIds, find all the parent roles, returns a promise with all names\nAuth.prototype._getAllRolesNamesForRoleIds = function(roleIDs, names = [], queriedRoles = {}) {\n  const ins = roleIDs.filter((roleID) => {\n    return queriedRoles[roleID] !== true;\n  }).map((roleID) => {\n    // mark as queried\n    queriedRoles[roleID] = true;\n    return {\n      __type: 'Pointer',\n      className: '_Role',\n      objectId: roleID\n    }\n  });\n\n  // all roles are accounted for, return the names\n  if (ins.length == 0) {\n    return Promise.resolve([...new Set(names)]);\n  }\n  // Build an OR query across all parentRoles\n  let restWhere;\n  if (ins.length == 1) {\n    restWhere = { 'roles': ins[0] };\n  } else {\n    restWhere = { 'roles': { '$in': ins }}\n  }\n  const query = new RestQuery(this.config, master(this.config), '_Role', restWhere, {});\n  return query.execute().then((response) => {\n    var results = response.results;\n    // Nothing found\n    if (!results.length) {\n      return Promise.resolve(names);\n    }\n    // Map the results with all Ids and names\n    const resultMap = results.reduce((memo, role) => {\n      memo.names.push(role.name);\n      memo.ids.push(role.objectId);\n      return memo;\n    }, {ids: [], names: []});\n    // store the new found names\n    names = names.concat(resultMap.names);\n    // find the next ones, circular roles will be cut\n    return this._getAllRolesNamesForRoleIds(resultMap.ids, names, queriedRoles)\n  }).then((names) => {\n    return Promise.resolve([...new Set(names)])\n  })\n}\n\nconst createSession = function(config, {\n  userId,\n  createdWith,\n  installationId,\n  additionalSessionData,\n}) {\n  const token = 'r:' + cryptoUtils.newToken();\n  const expiresAt = config.generateSessionExpiresAt();\n  const sessionData = {\n    sessionToken: token,\n    user: {\n      __type: 'Pointer',\n      className: '_User',\n      objectId: userId\n    },\n    createdWith,\n    restricted: false,\n    expiresAt: Parse._encode(expiresAt)\n  };\n\n  if (installationId) {\n    sessionData.installationId = installationId\n  }\n\n  Object.assign(sessionData, additionalSessionData);\n  // We need to import RestWrite at this point for the cyclic dependency it has to it\n  const RestWrite = require('./RestWrite');\n\n  return {\n    sessionData,\n    createSession: () => new RestWrite(config, master(config), '_Session', null, sessionData).execute()\n  }\n}\n\nmodule.exports = {\n  Auth,\n  master,\n  nobody,\n  readOnly,\n  getAuthForSessionToken,\n  getAuthForLegacySessionToken,\n  createSession,\n};\n"]} \ No newline at end of file diff --git a/lib/ClientSDK.js b/lib/ClientSDK.js index 6e029ceb07..a89dd54ddd 100644 --- a/lib/ClientSDK.js +++ b/lib/ClientSDK.js @@ -39,4 +39,5 @@ module.exports = { compatible, supportsForwardDelete, fromString -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Config.js b/lib/Config.js index 71c74906e1..83218c8b9a 100644 --- a/lib/Config.js +++ b/lib/Config.js @@ -289,4 +289,5 @@ class Config { exports.Config = Config; exports.default = Config; -module.exports = Config; \ No newline at end of file +module.exports = Config; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Config.js"],"names":["removeTrailingSlash","str","endsWith","substr","length","Config","get","applicationId","mount","cacheInfo","AppCache","config","Object","keys","forEach","key","schemaCache","SchemaCache","cacheController","schemaCacheTTL","enableSingleSchemaCache","database","DatabaseController","databaseController","adapter","generateSessionExpiresAt","bind","generateEmailVerifyTokenExpiresAt","put","serverConfiguration","validate","appId","setupPasswordValidator","passwordPolicy","verifyUserEmails","userController","appName","publicServerURL","revokeSessionOnPasswordReset","expireInactiveSessions","sessionLength","maxLimit","emailVerifyTokenValidityDuration","accountLockout","masterKeyIps","masterKey","readOnlyMasterKey","Error","emailAdapter","validateEmailConfiguration","validateAccountLockoutPolicy","validatePasswordPolicy","startsWith","validateSessionConfiguration","validateMasterKeyIps","validateMaxLimit","duration","Number","isInteger","threshold","maxPasswordAge","undefined","resetTokenValidityDuration","validatorPattern","RegExp","validatorCallback","doNotAllowUsername","maxPasswordHistory","patternValidator","value","test","isNaN","ip","net","isIP","_mount","newValue","now","Date","getTime","generatePasswordResetTokenExpiresAt","invalidLinkURL","customPages","invalidLink","invalidVerificationLinkURL","invalidVerificationLink","linkSendSuccessURL","linkSendSuccess","linkSendFailURL","linkSendFail","verifyEmailSuccessURL","verifyEmailSuccess","choosePasswordURL","choosePassword","requestResetPasswordURL","passwordResetSuccessURL","passwordResetSuccess","parseFrameURL","verifyEmailURL","module","exports"],"mappings":"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","file":"Config.js","sourcesContent":["// A Config object provides information about how a specific app is\n// configured.\n// mount is the URL for the root of the API; includes http, domain, etc.\n\nimport AppCache from './cache';\nimport SchemaCache from './Controllers/SchemaCache';\nimport DatabaseController from './Controllers/DatabaseController';\nimport net from 'net';\n\nfunction removeTrailingSlash(str) {\n  if (!str) {\n    return str;\n  }\n  if (str.endsWith(\"/\")) {\n    str = str.substr(0, str.length - 1);\n  }\n  return str;\n}\n\nexport class Config {\n  static get(applicationId: string, mount: string) {\n    const cacheInfo = AppCache.get(applicationId);\n    if (!cacheInfo) {\n      return;\n    }\n    const config = new Config();\n    config.applicationId = applicationId;\n    Object.keys(cacheInfo).forEach((key) => {\n      if (key == 'databaseController') {\n        const schemaCache = new SchemaCache(cacheInfo.cacheController,\n          cacheInfo.schemaCacheTTL,\n          cacheInfo.enableSingleSchemaCache);\n        config.database = new DatabaseController(cacheInfo.databaseController.adapter, schemaCache);\n      } else {\n        config[key] = cacheInfo[key];\n      }\n    });\n    config.mount = removeTrailingSlash(mount);\n    config.generateSessionExpiresAt = config.generateSessionExpiresAt.bind(config);\n    config.generateEmailVerifyTokenExpiresAt = config.generateEmailVerifyTokenExpiresAt.bind(config);\n    return config;\n  }\n\n  static put(serverConfiguration) {\n    Config.validate(serverConfiguration);\n    AppCache.put(serverConfiguration.appId, serverConfiguration);\n    Config.setupPasswordValidator(serverConfiguration.passwordPolicy);\n    return serverConfiguration;\n  }\n\n  static validate({\n    verifyUserEmails,\n    userController,\n    appName,\n    publicServerURL,\n    revokeSessionOnPasswordReset,\n    expireInactiveSessions,\n    sessionLength,\n    maxLimit,\n    emailVerifyTokenValidityDuration,\n    accountLockout,\n    passwordPolicy,\n    masterKeyIps,\n    masterKey,\n    readOnlyMasterKey,\n  }) {\n\n    if (masterKey === readOnlyMasterKey) {\n      throw new Error('masterKey and readOnlyMasterKey should be different');\n    }\n\n    const emailAdapter = userController.adapter;\n    if (verifyUserEmails) {\n      this.validateEmailConfiguration({emailAdapter, appName, publicServerURL, emailVerifyTokenValidityDuration});\n    }\n\n    this.validateAccountLockoutPolicy(accountLockout);\n\n    this.validatePasswordPolicy(passwordPolicy);\n\n    if (typeof revokeSessionOnPasswordReset !== 'boolean') {\n      throw 'revokeSessionOnPasswordReset must be a boolean value';\n    }\n\n    if (publicServerURL) {\n      if (!publicServerURL.startsWith(\"http://\") && !publicServerURL.startsWith(\"https://\")) {\n        throw \"publicServerURL should be a valid HTTPS URL starting with https://\"\n      }\n    }\n\n    this.validateSessionConfiguration(sessionLength, expireInactiveSessions);\n\n    this.validateMasterKeyIps(masterKeyIps);\n\n    this.validateMaxLimit(maxLimit);\n  }\n\n  static validateAccountLockoutPolicy(accountLockout) {\n    if (accountLockout) {\n      if (typeof accountLockout.duration !== 'number' || accountLockout.duration <= 0 || accountLockout.duration > 99999) {\n        throw 'Account lockout duration should be greater than 0 and less than 100000';\n      }\n\n      if (!Number.isInteger(accountLockout.threshold) || accountLockout.threshold < 1 || accountLockout.threshold > 999) {\n        throw 'Account lockout threshold should be an integer greater than 0 and less than 1000';\n      }\n    }\n  }\n\n  static validatePasswordPolicy(passwordPolicy) {\n    if (passwordPolicy) {\n      if (passwordPolicy.maxPasswordAge !== undefined && (typeof passwordPolicy.maxPasswordAge !== 'number' || passwordPolicy.maxPasswordAge < 0)) {\n        throw 'passwordPolicy.maxPasswordAge must be a positive number';\n      }\n\n      if (passwordPolicy.resetTokenValidityDuration !== undefined && (typeof passwordPolicy.resetTokenValidityDuration !== 'number' || passwordPolicy.resetTokenValidityDuration <= 0)) {\n        throw 'passwordPolicy.resetTokenValidityDuration must be a positive number';\n      }\n\n      if(passwordPolicy.validatorPattern){\n        if(typeof(passwordPolicy.validatorPattern) === 'string') {\n          passwordPolicy.validatorPattern = new RegExp(passwordPolicy.validatorPattern);\n        }\n        else if(!(passwordPolicy.validatorPattern instanceof RegExp)){\n          throw 'passwordPolicy.validatorPattern must be a regex string or RegExp object.';\n        }\n      }\n\n\n      if(passwordPolicy.validatorCallback && typeof passwordPolicy.validatorCallback !== 'function') {\n        throw 'passwordPolicy.validatorCallback must be a function.';\n      }\n\n      if(passwordPolicy.doNotAllowUsername && typeof passwordPolicy.doNotAllowUsername !== 'boolean') {\n        throw 'passwordPolicy.doNotAllowUsername must be a boolean value.';\n      }\n\n      if (passwordPolicy.maxPasswordHistory && (!Number.isInteger(passwordPolicy.maxPasswordHistory) || passwordPolicy.maxPasswordHistory <= 0 || passwordPolicy.maxPasswordHistory > 20)) {\n        throw 'passwordPolicy.maxPasswordHistory must be an integer ranging 0 - 20';\n      }\n    }\n  }\n\n  // if the passwordPolicy.validatorPattern is configured then setup a callback to process the pattern\n  static setupPasswordValidator(passwordPolicy) {\n    if (passwordPolicy && passwordPolicy.validatorPattern) {\n      passwordPolicy.patternValidator = (value) => {\n        return passwordPolicy.validatorPattern.test(value);\n      }\n    }\n  }\n\n  static validateEmailConfiguration({emailAdapter, appName, publicServerURL, emailVerifyTokenValidityDuration}) {\n    if (!emailAdapter) {\n      throw 'An emailAdapter is required for e-mail verification and password resets.';\n    }\n    if (typeof appName !== 'string') {\n      throw 'An app name is required for e-mail verification and password resets.';\n    }\n    if (typeof publicServerURL !== 'string') {\n      throw 'A public server url is required for e-mail verification and password resets.';\n    }\n    if (emailVerifyTokenValidityDuration) {\n      if (isNaN(emailVerifyTokenValidityDuration)) {\n        throw 'Email verify token validity duration must be a valid number.';\n      } else if (emailVerifyTokenValidityDuration <= 0) {\n        throw 'Email verify token validity duration must be a value greater than 0.'\n      }\n    }\n  }\n\n  static validateMasterKeyIps(masterKeyIps) {\n    for (const ip of masterKeyIps) {\n      if(!net.isIP(ip)){\n        throw `Invalid ip in masterKeyIps: ${ip}`;\n      }\n    }\n  }\n\n  get mount() {\n    var mount = this._mount;\n    if (this.publicServerURL) {\n      mount = this.publicServerURL;\n    }\n    return mount;\n  }\n\n  set mount(newValue) {\n    this._mount = newValue;\n  }\n\n  static validateSessionConfiguration(sessionLength, expireInactiveSessions) {\n    if (expireInactiveSessions) {\n      if (isNaN(sessionLength)) {\n        throw 'Session length must be a valid number.';\n      }\n      else if (sessionLength <= 0) {\n        throw 'Session length must be a value greater than 0.'\n      }\n    }\n  }\n\n  static validateMaxLimit(maxLimit) {\n    if (maxLimit <= 0) {\n      throw 'Max limit must be a value greater than 0.'\n    }\n  }\n\n  generateEmailVerifyTokenExpiresAt() {\n    if (!this.verifyUserEmails || !this.emailVerifyTokenValidityDuration) {\n      return undefined;\n    }\n    var now = new Date();\n    return new Date(now.getTime() + (this.emailVerifyTokenValidityDuration * 1000));\n  }\n\n  generatePasswordResetTokenExpiresAt() {\n    if (!this.passwordPolicy || !this.passwordPolicy.resetTokenValidityDuration) {\n      return undefined;\n    }\n    const now = new Date();\n    return new Date(now.getTime() + (this.passwordPolicy.resetTokenValidityDuration * 1000));\n  }\n\n  generateSessionExpiresAt() {\n    if (!this.expireInactiveSessions) {\n      return undefined;\n    }\n    var now = new Date();\n    return new Date(now.getTime() + (this.sessionLength * 1000));\n  }\n\n  get invalidLinkURL() {\n    return this.customPages.invalidLink || `${this.publicServerURL}/apps/invalid_link.html`;\n  }\n\n  get invalidVerificationLinkURL() {\n    return this.customPages.invalidVerificationLink || `${this.publicServerURL}/apps/invalid_verification_link.html`;\n  }\n\n  get linkSendSuccessURL() {\n    return this.customPages.linkSendSuccess || `${this.publicServerURL}/apps/link_send_success.html`\n  }\n\n  get linkSendFailURL() {\n    return this.customPages.linkSendFail || `${this.publicServerURL}/apps/link_send_fail.html`\n  }\n\n  get verifyEmailSuccessURL() {\n    return this.customPages.verifyEmailSuccess || `${this.publicServerURL}/apps/verify_email_success.html`;\n  }\n\n  get choosePasswordURL() {\n    return this.customPages.choosePassword || `${this.publicServerURL}/apps/choose_password`;\n  }\n\n  get requestResetPasswordURL() {\n    return `${this.publicServerURL}/apps/${this.applicationId}/request_password_reset`;\n  }\n\n  get passwordResetSuccessURL() {\n    return this.customPages.passwordResetSuccess || `${this.publicServerURL}/apps/password_reset_success.html`;\n  }\n\n  get parseFrameURL() {\n    return this.customPages.parseFrameURL;\n  }\n\n  get verifyEmailURL() {\n    return `${this.publicServerURL}/apps/${this.applicationId}/verify_email`;\n  }\n}\n\nexport default Config;\nmodule.exports = Config;\n"]} \ No newline at end of file diff --git a/lib/Controllers/AdaptableController.js b/lib/Controllers/AdaptableController.js index c782269d77..8405e53e57 100644 --- a/lib/Controllers/AdaptableController.js +++ b/lib/Controllers/AdaptableController.js @@ -83,4 +83,5 @@ class AdaptableController { } exports.AdaptableController = AdaptableController; -exports.default = AdaptableController; \ No newline at end of file +exports.default = AdaptableController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Controllers/AnalyticsController.js b/lib/Controllers/AnalyticsController.js index a54cf91666..1d2f826ef1 100644 --- a/lib/Controllers/AnalyticsController.js +++ b/lib/Controllers/AnalyticsController.js @@ -40,4 +40,5 @@ class AnalyticsController extends _AdaptableController2.default { } exports.AnalyticsController = AnalyticsController; -exports.default = AnalyticsController; \ No newline at end of file +exports.default = AnalyticsController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Controllers/CacheController.js b/lib/Controllers/CacheController.js index 5b0466cbb0..15aefc8298 100644 --- a/lib/Controllers/CacheController.js +++ b/lib/Controllers/CacheController.js @@ -88,4 +88,5 @@ class CacheController extends _AdaptableController2.default { } exports.CacheController = CacheController; -exports.default = CacheController; \ No newline at end of file +exports.default = CacheController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Controllers/DatabaseController.js b/lib/Controllers/DatabaseController.js index daf78ed9ae..afb8274205 100644 --- a/lib/Controllers/DatabaseController.js +++ b/lib/Controllers/DatabaseController.js @@ -80,7 +80,7 @@ const transformObjectACL = (_ref) => { return 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 specialQuerykeys = ['$and', '$or', '$nor', '_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; @@ -141,6 +141,14 @@ const validateQuery = query => { } } + if (query.$nor) { + if (query.$nor instanceof Array && query.$nor.length > 0) { + query.$nor.forEach(validateQuery); + } else { + throw new _node.Parse.Error(_node.Parse.Error.INVALID_QUERY, 'Bad $nor format - use an array of at least 1 value.'); + } + } + Object.keys(query).forEach(key => { if (query && query[key] && query[key].$regex) { if (typeof query[key].$options === 'string') { @@ -177,6 +185,7 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => { delete object._failed_login_count; delete object._account_lockout_expires_at; delete object._password_changed_at; + delete object._password_history; if (aclGroup.indexOf(object.objectId) > -1) { return object; @@ -315,6 +324,16 @@ const untransformObjectACL = (_ref2) => { return output; }; +/** + * When querying, the fieldName may be compound, extract the root fieldName + * `temperature.celsius` becomes `temperature` + * @param {string} fieldName that may be a compound field name + * @returns {string} the root name of the field + */ +const getRootFieldName = fieldName => { + return fieldName.split('.')[0]; +}; + const relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } }; class DatabaseController { @@ -422,13 +441,13 @@ class DatabaseController { if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`); } - fieldName = fieldName.split('.')[0]; - if (!SchemaController.fieldNameIsValid(fieldName) && !isSpecialUpdateKey(fieldName)) { + const rootFieldName = getRootFieldName(fieldName); + if (!SchemaController.fieldNameIsValid(rootFieldName) && !isSpecialUpdateKey(rootFieldName)) { throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`); } }); for (const updateOperation in update) { - if (Object.keys(updateOperation).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) { + if (update[updateOperation] && typeof update[updateOperation] === 'object' && Object.keys(update[updateOperation]).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) { throw new _node.Parse.Error(_node.Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters"); } } @@ -637,10 +656,15 @@ class DatabaseController { } // Won't delete collections in the system namespace - // Returns a promise. - deleteEverything() { + /** + * Delete all classes and clears the schema cache + * + * @param {boolean} fast set to true if it's ok to just delete rows and not indexes + * @returns {Promise} when the deletions completes + */ + deleteEverything(fast = false) { this.schemaPromise = null; - return Promise.all([this.adapter.deleteAllClasses(), this.schemaCache.clear()]); + return Promise.all([this.adapter.deleteAllClasses(fast), this.schemaCache.clear()]); } // Returns a promise for a list of related ids given an owning id. @@ -840,7 +864,8 @@ class DatabaseController { op, distinct, pipeline, - readPreference + readPreference, + isWrite } = {}) { const isMaster = acl === undefined; const aclGroup = acl || []; @@ -878,7 +903,8 @@ class DatabaseController { if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Cannot sort by ${fieldName}`); } - if (!SchemaController.fieldNameIsValid(fieldName)) { + const rootFieldName = getRootFieldName(fieldName); + if (!SchemaController.fieldNameIsValid(rootFieldName)) { throw new _node.Parse.Error(_node.Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`); } }); @@ -894,7 +920,11 @@ class DatabaseController { } } if (!isMaster) { - query = addReadACL(query, aclGroup); + if (isWrite) { + query = addWriteACL(query, aclGroup); + } else { + query = addReadACL(query, aclGroup); + } } validateQuery(query); if (count) { @@ -1037,4 +1067,5 @@ class DatabaseController { module.exports = DatabaseController; // Expose validateQuery for tests -module.exports._validateQuery = validateQuery; \ No newline at end of file +module.exports._validateQuery = validateQuery; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/DatabaseController.js"],"names":["SchemaController","addWriteACL","query","acl","newQuery","_","cloneDeep","_wperm","addReadACL","_rperm","transformObjectACL","ACL","result","entry","read","push","write","specialQuerykeys","isSpecialQueryKey","key","indexOf","validateQuery","Parse","Error","INVALID_QUERY","$or","Array","forEach","Object","keys","noCollisions","some","subq","hasOwnProperty","hasNears","subquery","$and","$nor","length","$regex","$options","match","INVALID_KEY_NAME","filterSensitiveData","isMaster","aclGroup","className","object","password","_hashed_password","sessionToken","_email_verify_token","_perishable_token","_perishable_token_expires_at","_tombstone","_email_verify_token_expires_at","_failed_login_count","_account_lockout_expires_at","_password_changed_at","_password_history","objectId","authData","specialKeysForUpdate","isSpecialUpdateKey","expandResultOnKeyPath","value","path","split","firstKey","nextPath","slice","join","sanitizeDatabaseResult","originalObject","response","Promise","resolve","keyUpdate","__op","joinTableName","flattenUpdateOperatorsForCreate","amount","INVALID_JSON","objects","COMMAND_UNAVAILABLE","transformAuthData","schema","provider","providerData","fieldName","fields","type","untransformObjectACL","output","getRootFieldName","relationSchema","relatedId","owningId","DatabaseController","constructor","adapter","schemaCache","schemaPromise","collectionExists","classExists","purgeCollection","loadSchema","then","schemaController","getOneSchema","deleteObjectsByQuery","validateClassName","classNameIsValid","reject","INVALID_CLASS_NAME","options","clearCache","load","redirectClassNameForKey","t","getExpectedType","targetClass","validateObject","undefined","s","canAddField","update","many","upsert","skipSanitization","originalQuery","originalUpdate","relationUpdates","validatePermission","collectRelationUpdates","addPointerPermissions","catch","error","rootFieldName","fieldNameIsValid","updateOperation","innerKey","includes","INVALID_NESTED_KEY","updateObjectsByQuery","upsertOneObject","findOneAndUpdate","OBJECT_NOT_FOUND","handleRelationUpdates","ops","deleteMe","process","op","x","pending","addRelation","removeRelation","all","fromClassName","fromId","toId","doc","code","destroy","parseFormatSchema","create","createdAt","iso","__type","updatedAt","enforceClassExists","reloadData","createObject","convertSchemaToAdapterSchema","classSchema","data","schemaFields","newKeys","filter","field","deleteEverything","fast","deleteAllClasses","clear","relatedIds","queryOptions","skip","limit","sort","findOptions","canSortOnJoinTables","find","results","map","owningIds","reduceInRelation","ors","aQuery","index","promises","queries","constraintKey","isNegation","r","q","ids","addNotInObjectIdsIds","addInObjectIdsIds","reduceRelationKeys","relatedTo","idsFromString","idsFromEq","idsFromIn","allIds","list","totalLength","reduce","memo","idsIntersection","intersect","big","$in","$eq","idsFromNin","Set","$nin","count","distinct","pipeline","readPreference","isWrite","_created_at","_updated_at","aggregate","INTERNAL_SERVER_ERROR","deleteSchema","deleteClass","wasParseCollection","relationFieldNames","name","operation","testBaseCLP","perms","userACL","userId","userPointer","permFields","assign","performInitialization","requiredUserFields","defaultColumns","_Default","_User","requiredRoleFields","_Role","userClassPromise","roleClassPromise","usernameUniqueness","ensureUniqueness","logger","warn","emailUniqueness","roleUniqueness","indexPromise","updateSchemaWithIndexes","adapterInit","VolatileClassesSchemas","module","exports","_validateQuery"],"mappings":"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","file":"DatabaseController.js","sourcesContent":["﻿// @flow\n// A database adapter that works with data exported from the hosted\n// Parse database.\n\n// @flow-disable-next\nimport { Parse }              from 'parse/node';\n// @flow-disable-next\nimport _                      from 'lodash';\n// @flow-disable-next\nimport intersect              from 'intersect';\n// @flow-disable-next\nimport deepcopy               from 'deepcopy';\nimport logger                 from '../logger';\nimport * as SchemaController       from './SchemaController';\nimport { StorageAdapter }     from '../Adapters/Storage/StorageAdapter';\nimport type { QueryOptions,\n  FullQueryOptions }          from '../Adapters/Storage/StorageAdapter';\n\nfunction addWriteACL(query, acl) {\n  const newQuery = _.cloneDeep(query);\n  //Can't be any existing '_wperm' query, we don't allow client queries on that, no need to $and\n  newQuery._wperm = { \"$in\" : [null, ...acl]};\n  return newQuery;\n}\n\nfunction addReadACL(query, acl) {\n  const newQuery = _.cloneDeep(query);\n  //Can't be any existing '_rperm' query, we don't allow client queries on that, no need to $and\n  newQuery._rperm = {\"$in\": [null, \"*\", ...acl]};\n  return newQuery;\n}\n\n// Transforms a REST API formatted ACL object to our two-field mongo format.\nconst transformObjectACL = ({ ACL, ...result }) => {\n  if (!ACL) {\n    return result;\n  }\n\n  result._wperm = [];\n  result._rperm = [];\n\n  for (const entry in ACL) {\n    if (ACL[entry].read) {\n      result._rperm.push(entry);\n    }\n    if (ACL[entry].write) {\n      result._wperm.push(entry);\n    }\n  }\n  return result;\n}\n\nconst specialQuerykeys = ['$and', '$or', '$nor', '_rperm', '_wperm', '_perishable_token', '_email_verify_token', '_email_verify_token_expires_at', '_account_lockout_expires_at', '_failed_login_count'];\n\nconst isSpecialQueryKey = key => {\n  return specialQuerykeys.indexOf(key) >= 0;\n}\n\nconst validateQuery = (query: any): void => {\n  if (query.ACL) {\n    throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Cannot query on ACL.');\n  }\n\n  if (query.$or) {\n    if (query.$or instanceof Array) {\n      query.$or.forEach(validateQuery);\n\n      /* In MongoDB, $or queries which are not alone at the top level of the\n       * query can not make efficient use of indexes due to a long standing\n       * bug known as SERVER-13732.\n       *\n       * This block restructures queries in which $or is not the sole top\n       * level element by moving all other top-level predicates inside every\n       * subdocument of the $or predicate, allowing MongoDB's query planner\n       * to make full use of the most relevant indexes.\n       *\n       * EG:      {$or: [{a: 1}, {a: 2}], b: 2}\n       * Becomes: {$or: [{a: 1, b: 2}, {a: 2, b: 2}]}\n       *\n       * The only exceptions are $near and $nearSphere operators, which are\n       * constrained to only 1 operator per query. As a result, these ops\n       * remain at the top level\n       *\n       * https://jira.mongodb.org/browse/SERVER-13732\n       * https://github.com/parse-community/parse-server/issues/3767\n       */\n      Object.keys(query).forEach(key => {\n        const noCollisions = !query.$or.some(subq => subq.hasOwnProperty(key))\n        let hasNears = false\n        if (query[key] != null && typeof query[key] == 'object') {\n          hasNears = ('$near' in query[key] || '$nearSphere' in query[key])\n        }\n        if (key != '$or' && noCollisions && !hasNears) {\n          query.$or.forEach(subquery => {\n            subquery[key] = query[key];\n          });\n          delete query[key];\n        }\n      });\n      query.$or.forEach(validateQuery);\n    } else {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Bad $or format - use an array value.');\n    }\n  }\n\n  if (query.$and) {\n    if (query.$and instanceof Array) {\n      query.$and.forEach(validateQuery);\n    } else {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Bad $and format - use an array value.');\n    }\n  }\n\n  if (query.$nor) {\n    if (query.$nor instanceof Array && query.$nor.length > 0) {\n      query.$nor.forEach(validateQuery);\n    } else {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Bad $nor format - use an array of at least 1 value.');\n    }\n  }\n\n  Object.keys(query).forEach(key => {\n    if (query && query[key] && query[key].$regex) {\n      if (typeof query[key].$options === 'string') {\n        if (!query[key].$options.match(/^[imxs]+$/)) {\n          throw new Parse.Error(Parse.Error.INVALID_QUERY, `Bad $options value for query: ${query[key].$options}`);\n        }\n      }\n    }\n    if (!isSpecialQueryKey(key) && !key.match(/^[a-zA-Z][a-zA-Z0-9_\\.]*$/)) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid key name: ${key}`);\n    }\n  });\n}\n\n// Filters out any data that shouldn't be on this REST-formatted object.\nconst filterSensitiveData = (isMaster, aclGroup, className, object) => {\n  if (className !== '_User') {\n    return object;\n  }\n\n  object.password = object._hashed_password;\n  delete object._hashed_password;\n\n  delete object.sessionToken;\n\n  if (isMaster) {\n    return object;\n  }\n  delete object._email_verify_token;\n  delete object._perishable_token;\n  delete object._perishable_token_expires_at;\n  delete object._tombstone;\n  delete object._email_verify_token_expires_at;\n  delete object._failed_login_count;\n  delete object._account_lockout_expires_at;\n  delete object._password_changed_at;\n  delete object._password_history;\n\n  if ((aclGroup.indexOf(object.objectId) > -1)) {\n    return object;\n  }\n  delete object.authData;\n  return object;\n};\n\nimport type { LoadSchemaOptions } from './types';\n\n// Runs an update on the database.\n// Returns a promise for an object with the new values for field\n// modifications that don't know their results ahead of time, like\n// 'increment'.\n// Options:\n//   acl:  a list of strings. If the object to be updated has an ACL,\n//         one of the provided strings must provide the caller with\n//         write permissions.\nconst 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', '_password_history'];\n\nconst isSpecialUpdateKey = key => {\n  return specialKeysForUpdate.indexOf(key) >= 0;\n}\n\nfunction expandResultOnKeyPath(object, key, value) {\n  if (key.indexOf('.') < 0) {\n    object[key] = value[key];\n    return object;\n  }\n  const path = key.split('.');\n  const firstKey = path[0];\n  const nextPath = path.slice(1).join('.');\n  object[firstKey] = expandResultOnKeyPath(object[firstKey] || {}, nextPath, value[firstKey]);\n  delete object[key];\n  return object;\n}\n\nfunction sanitizeDatabaseResult(originalObject, result): Promise<any> {\n  const response = {};\n  if (!result) {\n    return Promise.resolve(response);\n  }\n  Object.keys(originalObject).forEach(key => {\n    const keyUpdate = originalObject[key];\n    // determine if that was an op\n    if (keyUpdate && typeof keyUpdate === 'object' && keyUpdate.__op\n      && ['Add', 'AddUnique', 'Remove', 'Increment'].indexOf(keyUpdate.__op) > -1) {\n      // only valid ops that produce an actionable result\n      // the op may have happend on a keypath\n      expandResultOnKeyPath(response, key, result);\n    }\n  });\n  return Promise.resolve(response);\n}\n\nfunction joinTableName(className, key) {\n  return `_Join:${key}:${className}`;\n}\n\nconst flattenUpdateOperatorsForCreate = object => {\n  for (const key in object) {\n    if (object[key] && object[key].__op) {\n      switch (object[key].__op) {\n      case 'Increment':\n        if (typeof object[key].amount !== 'number') {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n        }\n        object[key] = object[key].amount;\n        break;\n      case 'Add':\n        if (!(object[key].objects instanceof Array)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n        }\n        object[key] = object[key].objects;\n        break;\n      case 'AddUnique':\n        if (!(object[key].objects instanceof Array)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n        }\n        object[key] = object[key].objects;\n        break;\n      case 'Remove':\n        if (!(object[key].objects instanceof Array)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, 'objects to add must be an array');\n        }\n        object[key] = []\n        break;\n      case 'Delete':\n        delete object[key];\n        break;\n      default:\n        throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE, `The ${object[key].__op} operator is not supported yet.`);\n      }\n    }\n  }\n}\n\nconst transformAuthData = (className, object, schema) => {\n  if (object.authData && className === '_User') {\n    Object.keys(object.authData).forEach(provider => {\n      const providerData = object.authData[provider];\n      const fieldName = `_auth_data_${provider}`;\n      if (providerData == null) {\n        object[fieldName] = {\n          __op: 'Delete'\n        }\n      } else {\n        object[fieldName] = providerData;\n        schema.fields[fieldName] = { type: 'Object' }\n      }\n    });\n    delete object.authData;\n  }\n}\n// Transforms a Database format ACL to a REST API format ACL\nconst untransformObjectACL = ({_rperm, _wperm, ...output}) => {\n  if (_rperm || _wperm) {\n    output.ACL = {};\n\n    (_rperm || []).forEach(entry => {\n      if (!output.ACL[entry]) {\n        output.ACL[entry] = { read: true };\n      } else {\n        output.ACL[entry]['read'] = true;\n      }\n    });\n\n    (_wperm || []).forEach(entry => {\n      if (!output.ACL[entry]) {\n        output.ACL[entry] = { write: true };\n      } else {\n        output.ACL[entry]['write'] = true;\n      }\n    });\n  }\n  return output;\n}\n\n/**\n * When querying, the fieldName may be compound, extract the root fieldName\n *     `temperature.celsius` becomes `temperature`\n * @param {string} fieldName that may be a compound field name\n * @returns {string} the root name of the field\n */\nconst getRootFieldName = (fieldName: string): string => {\n  return fieldName.split('.')[0]\n}\n\nconst relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } };\n\nclass DatabaseController {\n  adapter: StorageAdapter;\n  schemaCache: any;\n  schemaPromise: ?Promise<SchemaController.SchemaController>;\n\n  constructor(adapter: StorageAdapter, schemaCache: any) {\n    this.adapter = adapter;\n    this.schemaCache = schemaCache;\n    // We don't want a mutable this.schema, because then you could have\n    // one request that uses different schemas for different parts of\n    // it. Instead, use loadSchema to get a schema.\n    this.schemaPromise = null;\n  }\n\n  collectionExists(className: string): Promise<boolean> {\n    return this.adapter.classExists(className);\n  }\n\n  purgeCollection(className: string): Promise<void> {\n    return this.loadSchema()\n      .then(schemaController => schemaController.getOneSchema(className))\n      .then(schema => this.adapter.deleteObjectsByQuery(className, schema, {}));\n  }\n\n  validateClassName(className: string): Promise<void> {\n    if (!SchemaController.classNameIsValid(className)) {\n      return Promise.reject(new Parse.Error(Parse.Error.INVALID_CLASS_NAME, 'invalid className: ' + className));\n    }\n    return Promise.resolve();\n  }\n\n  // Returns a promise for a schemaController.\n  loadSchema(options: LoadSchemaOptions = {clearCache: false}): Promise<SchemaController.SchemaController> {\n    if (this.schemaPromise != null) {\n      return this.schemaPromise;\n    }\n    this.schemaPromise = SchemaController.load(this.adapter, this.schemaCache, options);\n    this.schemaPromise.then(() => delete this.schemaPromise,\n      () => delete this.schemaPromise);\n    return this.loadSchema(options);\n  }\n\n  // Returns a promise for the classname that is related to the given\n  // classname through the key.\n  // TODO: make this not in the DatabaseController interface\n  redirectClassNameForKey(className: string, key: string): Promise<?string> {\n    return this.loadSchema().then((schema) => {\n      var t  = schema.getExpectedType(className, key);\n      if (t != null && typeof t !== 'string' && t.type === 'Relation') {\n        return t.targetClass;\n      }\n      return className;\n    });\n  }\n\n  // Uses the schema to validate the object (REST API format).\n  // Returns a promise that resolves to the new schema.\n  // This does not update this.schema, because in a situation like a\n  // batch request, that could confuse other users of the schema.\n  validateObject(className: string, object: any, query: any, { acl }: QueryOptions): Promise<boolean> {\n    let schema;\n    const isMaster = acl === undefined;\n    var aclGroup: string[]  = acl || [];\n    return this.loadSchema().then(s => {\n      schema = s;\n      if (isMaster) {\n        return Promise.resolve();\n      }\n      return this.canAddField(schema, className, object, aclGroup);\n    }).then(() => {\n      return schema.validateObject(className, object, query);\n    });\n  }\n\n  update(className: string, query: any, update: any, {\n    acl,\n    many,\n    upsert,\n  }: FullQueryOptions = {}, skipSanitization: boolean = false): Promise<any> {\n    const originalQuery = query;\n    const originalUpdate = update;\n    // Make a copy of the object, so we don't mutate the incoming data.\n    update = deepcopy(update);\n    var relationUpdates = [];\n    var isMaster = acl === undefined;\n    var aclGroup = acl || [];\n    return this.loadSchema()\n      .then(schemaController => {\n        return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'update'))\n          .then(() => {\n            relationUpdates = this.collectRelationUpdates(className, originalQuery.objectId, update);\n            if (!isMaster) {\n              query = this.addPointerPermissions(schemaController, className, 'update', query, aclGroup);\n            }\n            if (!query) {\n              return Promise.resolve();\n            }\n            if (acl) {\n              query = addWriteACL(query, acl);\n            }\n            validateQuery(query);\n            return schemaController.getOneSchema(className, true)\n              .catch(error => {\n                // If the schema doesn't exist, pretend it exists with no fields. This behavior\n                // will likely need revisiting.\n                if (error === undefined) {\n                  return { fields: {} };\n                }\n                throw error;\n              })\n              .then(schema => {\n                Object.keys(update).forEach(fieldName => {\n                  if (fieldName.match(/^authData\\.([a-zA-Z0-9_]+)\\.id$/)) {\n                    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);\n                  }\n                  const rootFieldName = getRootFieldName(fieldName);\n                  if (!SchemaController.fieldNameIsValid(rootFieldName) && !isSpecialUpdateKey(rootFieldName)) {\n                    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`);\n                  }\n                });\n                for (const updateOperation in update) {\n                  if (update[updateOperation] && typeof update[updateOperation] === 'object' && Object.keys(update[updateOperation]).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) {\n                    throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, \"Nested keys should not contain the '$' or '.' characters\");\n                  }\n                }\n                update = transformObjectACL(update);\n                transformAuthData(className, update, schema);\n                if (many) {\n                  return this.adapter.updateObjectsByQuery(className, schema, query, update);\n                } else if (upsert) {\n                  return this.adapter.upsertOneObject(className, schema, query, update);\n                } else {\n                  return this.adapter.findOneAndUpdate(className, schema, query, update)\n                }\n              });\n          })\n          .then((result: any) => {\n            if (!result) {\n              throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n            }\n            return this.handleRelationUpdates(className, originalQuery.objectId, update, relationUpdates).then(() => {\n              return result;\n            });\n          }).then((result) => {\n            if (skipSanitization) {\n              return Promise.resolve(result);\n            }\n            return sanitizeDatabaseResult(originalUpdate, result);\n          });\n      });\n  }\n\n  // Collect all relation-updating operations from a REST-format update.\n  // Returns a list of all relation updates to perform\n  // This mutates update.\n  collectRelationUpdates(className: string, objectId: ?string, update: any) {\n    var ops = [];\n    var deleteMe = [];\n    objectId = update.objectId || objectId;\n\n    var process = (op, key) => {\n      if (!op) {\n        return;\n      }\n      if (op.__op == 'AddRelation') {\n        ops.push({key, op});\n        deleteMe.push(key);\n      }\n\n      if (op.__op == 'RemoveRelation') {\n        ops.push({key, op});\n        deleteMe.push(key);\n      }\n\n      if (op.__op == 'Batch') {\n        for (var x of op.ops) {\n          process(x, key);\n        }\n      }\n    };\n\n    for (const key in update) {\n      process(update[key], key);\n    }\n    for (const key of deleteMe) {\n      delete update[key];\n    }\n    return ops;\n  }\n\n  // Processes relation-updating operations from a REST-format update.\n  // Returns a promise that resolves when all updates have been performed\n  handleRelationUpdates(className: string, objectId: string, update: any, ops: any) {\n    var pending = [];\n    objectId = update.objectId || objectId;\n    ops.forEach(({key, op}) => {\n      if (!op) {\n        return;\n      }\n      if (op.__op == 'AddRelation') {\n        for (const object of op.objects) {\n          pending.push(this.addRelation(key, className,\n            objectId,\n            object.objectId));\n        }\n      }\n\n      if (op.__op == 'RemoveRelation') {\n        for (const object of op.objects) {\n          pending.push(this.removeRelation(key, className,\n            objectId,\n            object.objectId));\n        }\n      }\n    });\n\n    return Promise.all(pending);\n  }\n\n  // Adds a relation.\n  // Returns a promise that resolves successfully iff the add was successful.\n  addRelation(key: string, fromClassName: string, fromId: string, toId: string) {\n    const doc = {\n      relatedId: toId,\n      owningId: fromId\n    };\n    return this.adapter.upsertOneObject(`_Join:${key}:${fromClassName}`, relationSchema, doc, doc);\n  }\n\n  // Removes a relation.\n  // Returns a promise that resolves successfully iff the remove was\n  // successful.\n  removeRelation(key: string, fromClassName: string, fromId: string, toId: string) {\n    var doc = {\n      relatedId: toId,\n      owningId: fromId\n    };\n    return this.adapter.deleteObjectsByQuery(`_Join:${key}:${fromClassName}`, relationSchema, doc)\n      .catch(error => {\n        // We don't care if they try to delete a non-existent relation.\n        if (error.code == Parse.Error.OBJECT_NOT_FOUND) {\n          return;\n        }\n        throw error;\n      });\n  }\n\n  // Removes objects matches this query from the database.\n  // Returns a promise that resolves successfully iff the object was\n  // deleted.\n  // Options:\n  //   acl:  a list of strings. If the object to be updated has an ACL,\n  //         one of the provided strings must provide the caller with\n  //         write permissions.\n  destroy(className: string, query: any, { acl }: QueryOptions = {}): Promise<any> {\n    const isMaster = acl === undefined;\n    const aclGroup = acl || [];\n\n    return this.loadSchema()\n      .then(schemaController => {\n        return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'delete'))\n          .then(() => {\n            if (!isMaster) {\n              query = this.addPointerPermissions(schemaController, className, 'delete', query, aclGroup);\n              if (!query) {\n                throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n              }\n            }\n            // delete by query\n            if (acl) {\n              query = addWriteACL(query, acl);\n            }\n            validateQuery(query);\n            return schemaController.getOneSchema(className)\n              .catch(error => {\n              // If the schema doesn't exist, pretend it exists with no fields. This behavior\n              // will likely need revisiting.\n                if (error === undefined) {\n                  return { fields: {} };\n                }\n                throw error;\n              })\n              .then(parseFormatSchema => this.adapter.deleteObjectsByQuery(className, parseFormatSchema, query))\n              .catch(error => {\n              // When deleting sessions while changing passwords, don't throw an error if they don't have any sessions.\n                if (className === \"_Session\" && error.code === Parse.Error.OBJECT_NOT_FOUND) {\n                  return Promise.resolve({});\n                }\n                throw error;\n              });\n          });\n      });\n  }\n\n  // Inserts an object into the database.\n  // Returns a promise that resolves successfully iff the object saved.\n  create(className: string, object: any, { acl }: QueryOptions = {}): Promise<any> {\n  // Make a copy of the object, so we don't mutate the incoming data.\n    const originalObject = object;\n    object = transformObjectACL(object);\n\n    object.createdAt = { iso: object.createdAt, __type: 'Date' };\n    object.updatedAt = { iso: object.updatedAt, __type: 'Date' };\n\n    var isMaster = acl === undefined;\n    var aclGroup = acl || [];\n    const relationUpdates = this.collectRelationUpdates(className, null, object);\n    return this.validateClassName(className)\n      .then(() => this.loadSchema())\n      .then(schemaController => {\n        return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, 'create'))\n          .then(() => schemaController.enforceClassExists(className))\n          .then(() => schemaController.reloadData())\n          .then(() => schemaController.getOneSchema(className, true))\n          .then(schema => {\n            transformAuthData(className, object, schema);\n            flattenUpdateOperatorsForCreate(object);\n            return this.adapter.createObject(className, SchemaController.convertSchemaToAdapterSchema(schema), object);\n          })\n          .then(result => {\n            return this.handleRelationUpdates(className, object.objectId, object, relationUpdates).then(() => {\n              return sanitizeDatabaseResult(originalObject, result.ops[0])\n            });\n          });\n      })\n  }\n\n  canAddField(schema: SchemaController.SchemaController, className: string, object: any, aclGroup: string[]): Promise<void> {\n    const classSchema = schema.data[className];\n    if (!classSchema) {\n      return Promise.resolve();\n    }\n    const fields = Object.keys(object);\n    const schemaFields = Object.keys(classSchema);\n    const newKeys = fields.filter((field) => {\n      // Skip fields that are unset\n      if (object[field] && object[field].__op && object[field].__op === 'Delete') {\n        return false;\n      }\n      return schemaFields.indexOf(field) < 0;\n    });\n    if (newKeys.length > 0) {\n      return schema.validatePermission(className, aclGroup, 'addField');\n    }\n    return Promise.resolve();\n  }\n\n  // Won't delete collections in the system namespace\n  /**\n   * Delete all classes and clears the schema cache\n   *\n   * @param {boolean} fast set to true if it's ok to just delete rows and not indexes\n   * @returns {Promise<void>} when the deletions completes\n   */\n  deleteEverything(fast: boolean = false): Promise<any> {\n    this.schemaPromise = null;\n    return Promise.all([\n      this.adapter.deleteAllClasses(fast),\n      this.schemaCache.clear()\n    ]);\n  }\n\n\n  // Returns a promise for a list of related ids given an owning id.\n  // className here is the owning className.\n  relatedIds(className: string, key: string, owningId: string, queryOptions: QueryOptions): Promise<Array<string>> {\n    const { skip, limit, sort } = queryOptions;\n    const findOptions = {};\n    if (sort && sort.createdAt && this.adapter.canSortOnJoinTables) {\n      findOptions.sort = { '_id' : sort.createdAt };\n      findOptions.limit = limit;\n      findOptions.skip = skip;\n      queryOptions.skip = 0;\n    }\n    return this.adapter.find(joinTableName(className, key), relationSchema, { owningId }, findOptions)\n      .then(results => results.map(result => result.relatedId));\n  }\n\n  // Returns a promise for a list of owning ids given some related ids.\n  // className here is the owning className.\n  owningIds(className: string, key: string, relatedIds: string[]): Promise<string[]> {\n    return this.adapter.find(joinTableName(className, key), relationSchema, { relatedId: { '$in': relatedIds } }, {})\n      .then(results => results.map(result => result.owningId));\n  }\n\n  // Modifies query so that it no longer has $in on relation fields, or\n  // equal-to-pointer constraints on relation fields.\n  // Returns a promise that resolves when query is mutated\n  reduceInRelation(className: string, query: any, schema: any): Promise<any> {\n  // Search for an in-relation or equal-to-relation\n  // Make it sequential for now, not sure of paralleization side effects\n    if (query['$or']) {\n      const ors = query['$or'];\n      return Promise.all(ors.map((aQuery, index) => {\n        return this.reduceInRelation(className, aQuery, schema).then((aQuery) => {\n          query['$or'][index] = aQuery;\n        });\n      })).then(() => {\n        return Promise.resolve(query);\n      });\n    }\n\n    const promises = Object.keys(query).map((key) => {\n      const t = schema.getExpectedType(className, key);\n      if (!t || t.type !== 'Relation') {\n        return Promise.resolve(query);\n      }\n      let queries: ?any[] = null;\n      if (query[key] && (query[key]['$in'] || query[key]['$ne'] || query[key]['$nin'] || query[key].__type == 'Pointer')) {\n      // Build the list of queries\n        queries = Object.keys(query[key]).map((constraintKey) => {\n          let relatedIds;\n          let isNegation = false;\n          if (constraintKey === 'objectId') {\n            relatedIds = [query[key].objectId];\n          } else if (constraintKey == '$in') {\n            relatedIds = query[key]['$in'].map(r => r.objectId);\n          } else if (constraintKey == '$nin') {\n            isNegation = true;\n            relatedIds = query[key]['$nin'].map(r => r.objectId);\n          } else if (constraintKey == '$ne') {\n            isNegation = true;\n            relatedIds = [query[key]['$ne'].objectId];\n          } else {\n            return;\n          }\n          return {\n            isNegation,\n            relatedIds\n          }\n        });\n      } else {\n        queries = [{isNegation: false, relatedIds: []}];\n      }\n\n      // remove the current queryKey as we don,t need it anymore\n      delete query[key];\n      // execute each query independently to build the list of\n      // $in / $nin\n      const promises = queries.map((q) => {\n        if (!q) {\n          return Promise.resolve();\n        }\n        return this.owningIds(className, key, q.relatedIds).then((ids) => {\n          if (q.isNegation) {\n            this.addNotInObjectIdsIds(ids, query);\n          } else {\n            this.addInObjectIdsIds(ids, query);\n          }\n          return Promise.resolve();\n        });\n      });\n\n      return Promise.all(promises).then(() => {\n        return Promise.resolve();\n      })\n\n    })\n\n    return Promise.all(promises).then(() => {\n      return Promise.resolve(query);\n    })\n  }\n\n  // Modifies query so that it no longer has $relatedTo\n  // Returns a promise that resolves when query is mutated\n  reduceRelationKeys(className: string, query: any, queryOptions: any): ?Promise<void> {\n\n    if (query['$or']) {\n      return Promise.all(query['$or'].map((aQuery) => {\n        return this.reduceRelationKeys(className, aQuery, queryOptions);\n      }));\n    }\n\n    var relatedTo = query['$relatedTo'];\n    if (relatedTo) {\n      return this.relatedIds(\n        relatedTo.object.className,\n        relatedTo.key,\n        relatedTo.object.objectId,\n        queryOptions)\n        .then((ids) => {\n          delete query['$relatedTo'];\n          this.addInObjectIdsIds(ids, query);\n          return this.reduceRelationKeys(className, query, queryOptions);\n        }).then(() => {});\n    }\n  }\n\n  addInObjectIdsIds(ids: ?Array<string> = null, query: any) {\n    const idsFromString: ?Array<string> = typeof query.objectId === 'string' ? [query.objectId] : null;\n    const idsFromEq: ?Array<string> = query.objectId && query.objectId['$eq'] ? [query.objectId['$eq']] : null;\n    const idsFromIn: ?Array<string> = query.objectId && query.objectId['$in'] ? query.objectId['$in'] : null;\n\n    // @flow-disable-next\n    const allIds: Array<Array<string>> = [idsFromString, idsFromEq, idsFromIn, ids].filter(list => list !== null);\n    const totalLength = allIds.reduce((memo, list) => memo + list.length, 0);\n\n    let idsIntersection = [];\n    if (totalLength > 125) {\n      idsIntersection = intersect.big(allIds);\n    } else {\n      idsIntersection = intersect(allIds);\n    }\n\n    // Need to make sure we don't clobber existing shorthand $eq constraints on objectId.\n    if (!('objectId' in query)) {\n      query.objectId = {\n        $in: undefined,\n      };\n    } else if (typeof query.objectId === 'string') {\n      query.objectId = {\n        $in: undefined,\n        $eq: query.objectId\n      };\n    }\n    query.objectId['$in'] = idsIntersection;\n\n    return query;\n  }\n\n  addNotInObjectIdsIds(ids: string[] = [], query: any) {\n    const idsFromNin = query.objectId && query.objectId['$nin'] ? query.objectId['$nin'] : [];\n    let allIds = [...idsFromNin,...ids].filter(list => list !== null);\n\n    // make a set and spread to remove duplicates\n    allIds = [...new Set(allIds)];\n\n    // Need to make sure we don't clobber existing shorthand $eq constraints on objectId.\n    if (!('objectId' in query)) {\n      query.objectId = {\n        $nin: undefined,\n      };\n    } else if (typeof query.objectId === 'string') {\n      query.objectId = {\n        $nin: undefined,\n        $eq: query.objectId\n      };\n    }\n\n    query.objectId['$nin'] = allIds;\n    return query;\n  }\n\n  // Runs a query on the database.\n  // Returns a promise that resolves to a list of items.\n  // Options:\n  //   skip    number of results to skip.\n  //   limit   limit to this number of results.\n  //   sort    an object where keys are the fields to sort by.\n  //           the value is +1 for ascending, -1 for descending.\n  //   count   run a count instead of returning results.\n  //   acl     restrict this operation with an ACL for the provided array\n  //           of user objectIds and roles. acl: null means no user.\n  //           when this field is not present, don't do anything regarding ACLs.\n  // TODO: make userIds not needed here. The db adapter shouldn't know\n  // anything about users, ideally. Then, improve the format of the ACL\n  // arg to work like the others.\n  find(className: string, query: any, {\n    skip,\n    limit,\n    acl,\n    sort = {},\n    count,\n    keys,\n    op,\n    distinct,\n    pipeline,\n    readPreference,\n    isWrite,\n  }: any = {}): Promise<any> {\n    const isMaster = acl === undefined;\n    const aclGroup = acl || [];\n    op = op || (typeof query.objectId == 'string' && Object.keys(query).length === 1 ? 'get' : 'find');\n    // Count operation if counting\n    op = (count === true ? 'count' : op);\n\n    let classExists = true;\n    return this.loadSchema()\n      .then(schemaController => {\n        //Allow volatile classes if querying with Master (for _PushStatus)\n        //TODO: Move volatile classes concept into mongo adapter, postgres adapter shouldn't care\n        //that api.parse.com breaks when _PushStatus exists in mongo.\n        return schemaController.getOneSchema(className, isMaster)\n          .catch(error => {\n          // Behavior for non-existent classes is kinda weird on Parse.com. Probably doesn't matter too much.\n          // For now, pretend the class exists but has no objects,\n            if (error === undefined) {\n              classExists = false;\n              return { fields: {} };\n            }\n            throw error;\n          })\n          .then(schema => {\n          // Parse.com treats queries on _created_at and _updated_at as if they were queries on createdAt and updatedAt,\n          // so duplicate that behavior here. If both are specified, the correct behavior to match Parse.com is to\n          // use the one that appears first in the sort list.\n            if (sort._created_at) {\n              sort.createdAt = sort._created_at;\n              delete sort._created_at;\n            }\n            if (sort._updated_at) {\n              sort.updatedAt = sort._updated_at;\n              delete sort._updated_at;\n            }\n            const queryOptions = { skip, limit, sort, keys, readPreference };\n            Object.keys(sort).forEach(fieldName => {\n              if (fieldName.match(/^authData\\.([a-zA-Z0-9_]+)\\.id$/)) {\n                throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Cannot sort by ${fieldName}`);\n              }\n              const rootFieldName = getRootFieldName(fieldName);\n              if (!SchemaController.fieldNameIsValid(rootFieldName)) {\n                throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`);\n              }\n            });\n            return (isMaster ? Promise.resolve() : schemaController.validatePermission(className, aclGroup, op))\n              .then(() => this.reduceRelationKeys(className, query, queryOptions))\n              .then(() => this.reduceInRelation(className, query, schemaController))\n              .then(() => {\n                if (!isMaster) {\n                  query = this.addPointerPermissions(schemaController, className, op, query, aclGroup);\n                }\n                if (!query) {\n                  if (op == 'get') {\n                    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n                  } else {\n                    return [];\n                  }\n                }\n                if (!isMaster) {\n                  if (isWrite) {\n                    query = addWriteACL(query, aclGroup);\n                  } else {\n                    query = addReadACL(query, aclGroup);\n                  }\n                }\n                validateQuery(query);\n                if (count) {\n                  if (!classExists) {\n                    return 0;\n                  } else {\n                    return this.adapter.count(className, schema, query, readPreference);\n                  }\n                }  else if (distinct) {\n                  if (!classExists) {\n                    return [];\n                  } else {\n                    return this.adapter.distinct(className, schema, query, distinct);\n                  }\n                }  else if (pipeline) {\n                  if (!classExists) {\n                    return [];\n                  } else {\n                    return this.adapter.aggregate(className, schema, pipeline, readPreference);\n                  }\n                } else {\n                  return this.adapter.find(className, schema, query, queryOptions)\n                    .then(objects => objects.map(object => {\n                      object = untransformObjectACL(object);\n                      return filterSensitiveData(isMaster, aclGroup, className, object)\n                    })).catch((error) => {\n                      throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, error);\n                    });\n                }\n              });\n          });\n      });\n  }\n\n  deleteSchema(className: string): Promise<void> {\n    return this.loadSchema({ clearCache: true })\n      .then(schemaController => schemaController.getOneSchema(className, true))\n      .catch(error => {\n        if (error === undefined) {\n          return { fields: {} };\n        } else {\n          throw error;\n        }\n      })\n      .then((schema: any) => {\n        return this.collectionExists(className)\n          .then(() => this.adapter.count(className, { fields: {} }))\n          .then(count => {\n            if (count > 0) {\n              throw new Parse.Error(255, `Class ${className} is not empty, contains ${count} objects, cannot drop schema.`);\n            }\n            return this.adapter.deleteClass(className);\n          })\n          .then(wasParseCollection => {\n            if (wasParseCollection) {\n              const relationFieldNames = Object.keys(schema.fields).filter(fieldName => schema.fields[fieldName].type === 'Relation');\n              return Promise.all(relationFieldNames.map(name => this.adapter.deleteClass(joinTableName(className, name)))).then(() => {\n                return;\n              });\n            } else {\n              return Promise.resolve();\n            }\n          });\n      })\n  }\n\n  addPointerPermissions(schema: any, className: string, operation: string, query: any, aclGroup: any[] = []) {\n  // Check if class has public permission for operation\n  // If the BaseCLP pass, let go through\n    if (schema.testBaseCLP(className, aclGroup, operation)) {\n      return query;\n    }\n    const perms = schema.perms[className];\n    const field = ['get', 'find'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';\n    const userACL = aclGroup.filter((acl) => {\n      return acl.indexOf('role:') != 0 && acl != '*';\n    });\n    // the ACL should have exactly 1 user\n    if (perms && perms[field] && perms[field].length > 0) {\n    // No user set return undefined\n    // If the length is > 1, that means we didn't de-dupe users correctly\n      if (userACL.length != 1) {\n        return;\n      }\n      const userId = userACL[0];\n      const userPointer =  {\n        \"__type\": \"Pointer\",\n        \"className\": \"_User\",\n        \"objectId\": userId\n      };\n\n      const permFields = perms[field];\n      const ors = permFields.map((key) => {\n        const q = {\n          [key]: userPointer\n        };\n        // if we already have a constraint on the key, use the $and\n        if (query.hasOwnProperty(key)) {\n          return {'$and': [q, query]};\n        }\n        // otherwise just add the constaint\n        return Object.assign({}, query, {\n          [`${key}`]: userPointer,\n        })\n      });\n      if (ors.length > 1) {\n        return {'$or': ors};\n      }\n      return ors[0];\n    } else {\n      return query;\n    }\n  }\n\n  // TODO: create indexes on first creation of a _User object. Otherwise it's impossible to\n  // have a Parse app without it having a _User collection.\n  performInitialization() {\n    const requiredUserFields = { fields: { ...SchemaController.defaultColumns._Default, ...SchemaController.defaultColumns._User } };\n    const requiredRoleFields = { fields: { ...SchemaController.defaultColumns._Default, ...SchemaController.defaultColumns._Role } };\n\n    const userClassPromise = this.loadSchema()\n      .then(schema => schema.enforceClassExists('_User'))\n    const roleClassPromise = this.loadSchema()\n      .then(schema => schema.enforceClassExists('_Role'))\n\n    const usernameUniqueness = userClassPromise\n      .then(() => this.adapter.ensureUniqueness('_User', requiredUserFields, ['username']))\n      .catch(error => {\n        logger.warn('Unable to ensure uniqueness for usernames: ', error);\n        throw error;\n      });\n\n    const emailUniqueness = userClassPromise\n      .then(() => this.adapter.ensureUniqueness('_User', requiredUserFields, ['email']))\n      .catch(error => {\n        logger.warn('Unable to ensure uniqueness for user email addresses: ', error);\n        throw error;\n      });\n\n    const roleUniqueness = roleClassPromise\n      .then(() => this.adapter.ensureUniqueness('_Role', requiredRoleFields, ['name']))\n      .catch(error => {\n        logger.warn('Unable to ensure uniqueness for role name: ', error);\n        throw error;\n      });\n\n    const indexPromise = this.adapter.updateSchemaWithIndexes();\n\n    // Create tables for volatile classes\n    const adapterInit = this.adapter.performInitialization({ VolatileClassesSchemas: SchemaController.VolatileClassesSchemas });\n    return Promise.all([usernameUniqueness, emailUniqueness, roleUniqueness, adapterInit, indexPromise]);\n  }\n\n  static _validateQuery: ((any) => void)\n}\n\nmodule.exports = DatabaseController;\n// Expose validateQuery for tests\nmodule.exports._validateQuery = validateQuery;\n"]} \ No newline at end of file diff --git a/lib/Controllers/FilesController.js b/lib/Controllers/FilesController.js index 8cbfc6596f..eecc598bd6 100644 --- a/lib/Controllers/FilesController.js +++ b/lib/Controllers/FilesController.js @@ -42,9 +42,11 @@ class FilesController extends _AdaptableController2.default { contentType = _mime2.default.getType(filename); } - filename = (0, _cryptoUtils.randomHexString)(32) + '_' + filename; + if (!this.options.preserveFileName) { + filename = (0, _cryptoUtils.randomHexString)(32) + '_' + filename; + } - var location = this.adapter.getFileLocation(config, filename); + const location = this.adapter.getFileLocation(config, filename); return this.adapter.createFile(filename, data, contentType).then(() => { return Promise.resolve({ url: location, @@ -105,4 +107,5 @@ class FilesController extends _AdaptableController2.default { } exports.FilesController = FilesController; -exports.default = FilesController; \ No newline at end of file +exports.default = FilesController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/FilesController.js"],"names":["legacyFilesRegex","RegExp","FilesController","AdaptableController","getFileData","config","filename","adapter","createFile","data","contentType","extname","path","hasExtension","length","mime","getExtension","getType","options","preserveFileName","location","getFileLocation","then","Promise","resolve","url","name","deleteFile","expandFilesInObject","object","Array","map","obj","key","fileObject","fileKey","undefined","indexOf","encodeURIComponent","test","expectedAdapterType","FilesAdapter","getFileStream"],"mappings":"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","file":"FilesController.js","sourcesContent":["// FilesController.js\nimport { randomHexString } from '../cryptoUtils';\nimport AdaptableController from './AdaptableController';\nimport { FilesAdapter } from '../Adapters/Files/FilesAdapter';\nimport path from 'path';\nimport mime from 'mime';\n\nconst legacyFilesRegex = new RegExp(\"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}-.*\");\n\nexport class FilesController extends AdaptableController {\n\n  getFileData(config, filename) {\n    return this.adapter.getFileData(filename);\n  }\n\n  createFile(config, filename, data, contentType) {\n\n    const extname = path.extname(filename);\n\n    const hasExtension = extname.length > 0;\n\n    if (!hasExtension && contentType && mime.getExtension(contentType)) {\n      filename = filename + '.' + mime.getExtension(contentType);\n    } else if (hasExtension && !contentType) {\n      contentType = mime.getType(filename);\n    }\n\n    if (!this.options.preserveFileName) {\n      filename = randomHexString(32) + '_' + filename;\n    }\n\n    const location = this.adapter.getFileLocation(config, filename);\n    return this.adapter.createFile(filename, data, contentType).then(() => {\n      return Promise.resolve({\n        url: location,\n        name: filename\n      });\n    });\n  }\n\n  deleteFile(config, filename) {\n    return this.adapter.deleteFile(filename);\n  }\n\n  /**\n   * Find file references in REST-format object and adds the url key\n   * with the current mount point and app id.\n   * Object may be a single object or list of REST-format objects.\n   */\n  expandFilesInObject(config, object) {\n    if (object instanceof Array) {\n      object.map((obj) => this.expandFilesInObject(config, obj));\n      return;\n    }\n    if (typeof object !== 'object') {\n      return;\n    }\n    for (const key in object) {\n      const fileObject = object[key];\n      if (fileObject && fileObject['__type'] === 'File') {\n        if (fileObject['url']) {\n          continue;\n        }\n        const filename = fileObject['name'];\n        // all filenames starting with \"tfss-\" should be from files.parsetfss.com\n        // all filenames starting with a \"-\" seperated UUID should be from files.parse.com\n        // all other filenames have been migrated or created from Parse Server\n        if (config.fileKey === undefined) {\n          fileObject['url'] = this.adapter.getFileLocation(config, filename);\n        } else {\n          if (filename.indexOf('tfss-') === 0) {\n            fileObject['url'] = 'http://files.parsetfss.com/' + config.fileKey + '/' + encodeURIComponent(filename);\n          } else if (legacyFilesRegex.test(filename)) {\n            fileObject['url'] = 'http://files.parse.com/' + config.fileKey + '/' + encodeURIComponent(filename);\n          } else {\n            fileObject['url'] = this.adapter.getFileLocation(config, filename);\n          }\n        }\n      }\n    }\n  }\n\n  expectedAdapterType() {\n    return FilesAdapter;\n  }\n\n  getFileStream(config, filename) {\n    return this.adapter.getFileStream(filename);\n  }\n}\n\nexport default FilesController;\n"]} \ No newline at end of file diff --git a/lib/Controllers/HooksController.js b/lib/Controllers/HooksController.js index 438db85a7d..ae0ce6a26c 100644 --- a/lib/Controllers/HooksController.js +++ b/lib/Controllers/HooksController.js @@ -19,6 +19,16 @@ var request = _interopRequireWildcard(_request); var _logger = require("../logger"); +var _http = require("http"); + +var _http2 = _interopRequireDefault(_http); + +var _https = require("https"); + +var _https2 = _interopRequireDefault(_https); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } // -disable-next @@ -26,6 +36,12 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; const DefaultHooksCollectionName = "_Hooks"; // -disable-next + +const HTTPAgents = { + http: new _http2.default.Agent({ keepAlive: true }), + https: new _https2.default.Agent({ keepAlive: true }) +}; + class HooksController { constructor(applicationId, databaseController, webhookKey) { @@ -194,6 +210,9 @@ function wrapToHTTPRequest(hook, key) { body: JSON.stringify(jsonBody) }; + const agent = hook.url.startsWith('https') ? HTTPAgents['https'] : HTTPAgents['http']; + jsonRequest.agent = agent; + if (key) { jsonRequest.headers['X-Parse-Webhook-Key'] = key; } else { @@ -235,4 +254,5 @@ function wrapToHTTPRequest(hook, key) { }; } -exports.default = HooksController; \ No newline at end of file +exports.default = HooksController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/HooksController.js"],"names":["triggers","Parse","request","DefaultHooksCollectionName","HTTPAgents","http","Agent","keepAlive","https","HooksController","constructor","applicationId","databaseController","webhookKey","_applicationId","_webhookKey","database","load","_getHooks","then","hooks","forEach","hook","addHookToTriggers","getFunction","functionName","results","getFunctions","$exists","getTrigger","className","triggerName","getTriggers","deleteFunction","removeFunction","_removeHooks","deleteTrigger","removeTrigger","query","find","map","result","objectId","destroy","Promise","resolve","saveHook","url","Error","update","upsert","wrappedFunction","wrapToHTTPRequest","addTrigger","addFunction","addHook","createOrUpdateHook","aHook","Types","createHook","updateHook","key","req","res","jsonBody","i","object","toJSON","original","jsonRequest","headers","body","JSON","stringify","agent","startsWith","logger","warn","post","err","httpResponse","parse","e","error","code","partialResponse","substring","success","createdAt","updatedAt"],"mappings":"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","file":"HooksController.js","sourcesContent":["/** @flow weak */\n\nimport * as triggers        from \"../triggers\";\n// @flow-disable-next\nimport * as Parse           from \"parse/node\";\n// @flow-disable-next\nimport * as request         from \"request\";\nimport { logger }           from '../logger';\nimport http                 from 'http';\nimport https                from 'https';\n\nconst DefaultHooksCollectionName = \"_Hooks\";\nconst HTTPAgents = {\n  http: new http.Agent({ keepAlive: true }),\n  https: new https.Agent({ keepAlive: true }),\n}\n\nexport class HooksController {\n  _applicationId:string;\n  _webhookKey:string;\n  database: any;\n\n  constructor(applicationId:string, databaseController, webhookKey) {\n    this._applicationId = applicationId;\n    this._webhookKey = webhookKey;\n    this.database = databaseController;\n  }\n\n  load() {\n    return this._getHooks().then(hooks => {\n      hooks = hooks || [];\n      hooks.forEach((hook) => {\n        this.addHookToTriggers(hook);\n      });\n    });\n  }\n\n  getFunction(functionName) {\n    return this._getHooks({ functionName: functionName }).then(results => results[0]);\n  }\n\n  getFunctions() {\n    return this._getHooks({ functionName: { $exists: true } });\n  }\n\n  getTrigger(className, triggerName) {\n    return this._getHooks({ className: className, triggerName: triggerName }).then(results => results[0]);\n  }\n\n  getTriggers() {\n    return this._getHooks({ className: { $exists: true }, triggerName: { $exists: true } });\n  }\n\n  deleteFunction(functionName) {\n    triggers.removeFunction(functionName, this._applicationId);\n    return this._removeHooks({ functionName: functionName });\n  }\n\n  deleteTrigger(className, triggerName) {\n    triggers.removeTrigger(triggerName, className, this._applicationId);\n    return this._removeHooks({ className: className, triggerName: triggerName });\n  }\n\n  _getHooks(query = {}) {\n    return this.database.find(DefaultHooksCollectionName, query).then((results) => {\n      return results.map((result) => {\n        delete result.objectId;\n        return result;\n      });\n    });\n  }\n\n  _removeHooks(query) {\n    return this.database.destroy(DefaultHooksCollectionName, query).then(() => {\n      return Promise.resolve({});\n    });\n  }\n\n  saveHook(hook) {\n    var query;\n    if (hook.functionName && hook.url) {\n      query = { functionName: hook.functionName }\n    } else if (hook.triggerName && hook.className && hook.url) {\n      query = { className: hook.className, triggerName: hook.triggerName }\n    } else {\n      throw new Parse.Error(143, \"invalid hook declaration\");\n    }\n    return this.database.update(DefaultHooksCollectionName, query, hook, {upsert: true}).then(() => {\n      return Promise.resolve(hook);\n    })\n  }\n\n  addHookToTriggers(hook) {\n    var wrappedFunction = wrapToHTTPRequest(hook, this._webhookKey);\n    wrappedFunction.url = hook.url;\n    if (hook.className) {\n      triggers.addTrigger(hook.triggerName, hook.className, wrappedFunction, this._applicationId)\n    } else {\n      triggers.addFunction(hook.functionName, wrappedFunction, null, this._applicationId);\n    }\n  }\n\n  addHook(hook) {\n    this.addHookToTriggers(hook);\n    return this.saveHook(hook);\n  }\n\n  createOrUpdateHook(aHook) {\n    var hook;\n    if (aHook && aHook.functionName && aHook.url) {\n      hook = {};\n      hook.functionName = aHook.functionName;\n      hook.url = aHook.url;\n    } else if (aHook && aHook.className && aHook.url && aHook.triggerName && triggers.Types[aHook.triggerName]) {\n      hook = {};\n      hook.className = aHook.className;\n      hook.url = aHook.url;\n      hook.triggerName = aHook.triggerName;\n\n    } else {\n      throw new Parse.Error(143, \"invalid hook declaration\");\n    }\n\n    return this.addHook(hook);\n  }\n\n  createHook(aHook) {\n    if (aHook.functionName) {\n      return this.getFunction(aHook.functionName).then((result) => {\n        if (result) {\n          throw new Parse.Error(143, `function name: ${aHook.functionName} already exits`);\n        } else {\n          return this.createOrUpdateHook(aHook);\n        }\n      });\n    } else if (aHook.className && aHook.triggerName) {\n      return this.getTrigger(aHook.className, aHook.triggerName).then((result) => {\n        if (result) {\n          throw new Parse.Error(143, `class ${aHook.className} already has trigger ${aHook.triggerName}`);\n        }\n        return this.createOrUpdateHook(aHook);\n      });\n    }\n\n    throw new Parse.Error(143, \"invalid hook declaration\");\n  }\n\n  updateHook(aHook) {\n    if (aHook.functionName) {\n      return this.getFunction(aHook.functionName).then((result) => {\n        if (result) {\n          return this.createOrUpdateHook(aHook);\n        }\n        throw new Parse.Error(143, `no function named: ${aHook.functionName} is defined`);\n      });\n    } else if (aHook.className && aHook.triggerName) {\n      return this.getTrigger(aHook.className, aHook.triggerName).then((result) => {\n        if (result) {\n          return this.createOrUpdateHook(aHook);\n        }\n        throw new Parse.Error(143, `class ${aHook.className} does not exist`);\n      });\n    }\n    throw new Parse.Error(143, \"invalid hook declaration\");\n  }\n}\n\nfunction wrapToHTTPRequest(hook, key) {\n  return (req, res) => {\n    const jsonBody = {};\n    for (var i in req) {\n      jsonBody[i] = req[i];\n    }\n    if (req.object) {\n      jsonBody.object = req.object.toJSON();\n      jsonBody.object.className = req.object.className;\n    }\n    if (req.original) {\n      jsonBody.original = req.original.toJSON();\n      jsonBody.original.className = req.original.className;\n    }\n    const jsonRequest: any = {\n      headers: {\n        'Content-Type': 'application/json'\n      },\n      body: JSON.stringify(jsonBody),\n    };\n\n    const agent = hook.url.startsWith('https') ? HTTPAgents['https'] : HTTPAgents['http'];\n    jsonRequest.agent = agent;\n\n    if (key) {\n      jsonRequest.headers['X-Parse-Webhook-Key'] = key;\n    } else {\n      logger.warn('Making outgoing webhook request without webhookKey being set!');\n    }\n\n    request.post(hook.url, jsonRequest, function (err, httpResponse, body) {\n      var result;\n      if (body) {\n        if (typeof body === \"string\") {\n          try {\n            body = JSON.parse(body);\n          } catch (e) {\n            err = {\n              error: \"Malformed response\",\n              code: -1,\n              partialResponse: body.substring(0, 100)\n            };\n          }\n        }\n        if (!err) {\n          result = body.success;\n          err = body.error;\n        }\n      }\n\n      if (err) {\n        return res.error(err);\n      } else if (hook.triggerName === 'beforeSave') {\n        if (typeof result === 'object') {\n          delete result.createdAt;\n          delete result.updatedAt;\n        }\n        return res.success({object: result});\n      } else {\n        return res.success(result);\n      }\n    });\n  }\n}\n\nexport default HooksController;\n"]} \ No newline at end of file diff --git a/lib/Controllers/LiveQueryController.js b/lib/Controllers/LiveQueryController.js index 7ccd287d5e..e61a8cf1e4 100644 --- a/lib/Controllers/LiveQueryController.js +++ b/lib/Controllers/LiveQueryController.js @@ -55,4 +55,5 @@ class LiveQueryController { } exports.LiveQueryController = LiveQueryController; -exports.default = LiveQueryController; \ No newline at end of file +exports.default = LiveQueryController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Controllers/LoggerController.js b/lib/Controllers/LoggerController.js index 8c78f99fad..4ce29ddc96 100644 --- a/lib/Controllers/LoggerController.js +++ b/lib/Controllers/LoggerController.js @@ -253,4 +253,5 @@ class LoggerController extends _AdaptableController2.default { } exports.LoggerController = LoggerController; -exports.default = LoggerController; \ No newline at end of file +exports.default = LoggerController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/LoggerController.js"],"names":["MILLISECONDS_IN_A_DAY","LOG_STRING_TRUNCATE_LENGTH","truncationMarker","LogLevel","INFO","ERROR","LogOrder","DESCENDING","ASCENDING","logLevels","LoggerController","AdaptableController","constructor","adapter","appId","options","logLevel","level","verbose","index","indexOf","forEach","levelIndex","maskSensitiveUrl","urlString","urlObj","url","parse","query","sanitizedQuery","key","slice","pathname","maskSensitive","argArray","map","e","replace","Array","isArray","item","body","Object","keys","params","log","args","concat","arg","apply","info","arguments","error","warn","debug","silly","logRequest","method","headers","stringifiedBody","JSON","stringify","logResponse","result","stringifiedResponse","validDateTime","date","Date","isNaN","getTime","truncateLogMessage","string","length","truncated","substring","parseOptions","from","now","until","size","Number","order","getLogs","Parse","Error","PUSH_MISCONFIGURED","expectedAdapterType","LoggerAdapter"],"mappings":"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","file":"LoggerController.js","sourcesContent":["import { Parse } from 'parse/node';\nimport AdaptableController from './AdaptableController';\nimport { LoggerAdapter } from '../Adapters/Logger/LoggerAdapter';\nimport url from 'url';\n\nconst MILLISECONDS_IN_A_DAY = 24 * 60 * 60 * 1000;\nconst LOG_STRING_TRUNCATE_LENGTH = 1000;\nconst truncationMarker = '... (truncated)';\n\nexport const LogLevel = {\n  INFO: 'info',\n  ERROR: 'error'\n}\n\nexport const LogOrder = {\n  DESCENDING: 'desc',\n  ASCENDING: 'asc'\n}\n\nconst logLevels = [\n  'error',\n  'warn',\n  'info',\n  'debug',\n  'verbose',\n  'silly',\n]\n\nexport class LoggerController extends AdaptableController {\n\n  constructor(adapter, appId, options = {logLevel: 'info'}) {\n    super(adapter, appId, options);\n    let level = 'info';\n    if (options.verbose) {\n      level = 'verbose';\n    }\n    if (options.logLevel) {\n      level = options.logLevel;\n    }\n    const index = logLevels.indexOf(level); // info by default\n    logLevels.forEach((level, levelIndex) => {\n      if (levelIndex > index) { // silence the levels that are > maxIndex\n        this[level] = () => {};\n      }\n    });\n  }\n\n  maskSensitiveUrl(urlString) {\n    const urlObj = url.parse(urlString, true);\n    const query = urlObj.query;\n    let sanitizedQuery = '?';\n\n    for(const key in query) {\n      if(key !== 'password') {\n        // normal value\n        sanitizedQuery += key + '=' + query[key] + '&';\n      } else {\n        // password value, redact it\n        sanitizedQuery += key + '=' + '********' + '&';\n      }\n    }\n\n    // trim last character, ? or &\n    sanitizedQuery = sanitizedQuery.slice(0, -1);\n\n    // return original path name with sanitized params attached\n    return urlObj.pathname + sanitizedQuery;\n  }\n\n  maskSensitive(argArray) {\n    return argArray.map(e => {\n      if (!e) {\n        return e;\n      }\n\n      if (typeof e === 'string') {\n        return e.replace(/(password\".?:.?\")[^\"]*\"/g, '$1********\"');\n      }\n      // else it is an object...\n\n      // check the url\n      if (e.url) {\n        // for strings\n        if (typeof e.url === 'string') {\n          e.url = this.maskSensitiveUrl(e.url);\n        } else if (Array.isArray(e.url)) { // for strings in array\n          e.url = e.url.map(item => {\n            if (typeof item === 'string') {\n              return this.maskSensitiveUrl(item);\n            }\n\n            return item;\n          });\n        }\n      }\n\n      if (e.body) {\n        for (const key of Object.keys(e.body)) {\n          if (key === 'password') {\n            e.body[key] = '********';\n            break;\n          }\n        }\n      }\n\n      if (e.params) {\n        for (const key of Object.keys(e.params)) {\n          if (key === 'password') {\n            e.params[key] = '********';\n            break;\n          }\n        }\n      }\n\n      return e;\n    });\n  }\n\n  log(level, args) {\n    // make the passed in arguments object an array with the spread operator\n    args = this.maskSensitive([...args]);\n    args = [].concat(level, args.map((arg) => {\n      if (typeof arg === 'function') { return arg(); }\n      return arg;\n    }));\n    this.adapter.log.apply(this.adapter, args);\n  }\n\n  info() {\n    return this.log('info', arguments);\n  }\n\n  error() {\n    return this.log('error', arguments);\n  }\n\n  warn() {\n    return this.log('warn', arguments);\n  }\n\n  verbose() {\n    return this.log('verbose', arguments);\n  }\n\n  debug() {\n    return this.log('debug', arguments);\n  }\n\n  silly() {\n    return this.log('silly', arguments);\n  }\n\n  logRequest({\n    method,\n    url,\n    headers,\n    body\n  }) {\n    this.verbose(() => {\n      const stringifiedBody = JSON.stringify(body, null, 2);\n      return `REQUEST for [${method}] ${url}: ${stringifiedBody}`;\n    }, {\n      method,\n      url,\n      headers,\n      body\n    });\n  }\n\n  logResponse({\n    method,\n    url,\n    result\n  }) {\n    this.verbose(\n      () => { const stringifiedResponse = JSON.stringify(result, null, 2);\n        return `RESPONSE from [${method}] ${url}: ${stringifiedResponse}`;\n      },\n      {result: result}\n    );\n  }\n  // check that date input is valid\n  static validDateTime(date) {\n    if (!date) {\n      return null;\n    }\n    date = new Date(date);\n\n    if (!isNaN(date.getTime())) {\n      return date;\n    }\n\n    return null;\n  }\n\n  truncateLogMessage(string) {\n    if (string && string.length > LOG_STRING_TRUNCATE_LENGTH) {\n      const truncated = string.substring(0, LOG_STRING_TRUNCATE_LENGTH) + truncationMarker;\n      return truncated;\n    }\n\n    return string;\n  }\n\n  static parseOptions(options = {}) {\n    const from = LoggerController.validDateTime(options.from) ||\n      new Date(Date.now() - 7 * MILLISECONDS_IN_A_DAY);\n    const until = LoggerController.validDateTime(options.until) || new Date();\n    const size = Number(options.size) || 10;\n    const order = options.order || LogOrder.DESCENDING;\n    const level = options.level || LogLevel.INFO;\n\n    return {\n      from,\n      until,\n      size,\n      order,\n      level,\n    };\n  }\n\n  // Returns a promise for a {response} object.\n  // query params:\n  // level (optional) Level of logging you want to query for (info || error)\n  // from (optional) Start time for the search. Defaults to 1 week ago.\n  // until (optional) End time for the search. Defaults to current time.\n  // order (optional) Direction of results returned, either “asc” or “desc”. Defaults to “desc”.\n  // size (optional) Number of rows returned by search. Defaults to 10\n  getLogs(options = {}) {\n    if (!this.adapter) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Logger adapter is not available');\n    }\n    if (typeof this.adapter.query !== 'function') {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Querying logs is not supported with this adapter');\n    }\n    options = LoggerController.parseOptions(options);\n    return this.adapter.query(options);\n  }\n\n  expectedAdapterType() {\n    return LoggerAdapter;\n  }\n}\n\nexport default LoggerController;\n"]} \ No newline at end of file diff --git a/lib/Controllers/PushController.js b/lib/Controllers/PushController.js index 89599094ba..9c783a58fd 100644 --- a/lib/Controllers/PushController.js +++ b/lib/Controllers/PushController.js @@ -59,10 +59,12 @@ class PushController { let restUpdate = {}; if (typeof badge == 'string' && badge.toLowerCase() === 'increment') { restUpdate = { badge: { __op: 'Increment', amount: 1 } }; + } else if (typeof badge == 'object' && typeof badge.__op == 'string' && badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) { + restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }; } else if (Number(badge)) { restUpdate = { badge: badge }; } else { - throw "Invalid value for badge, expected number or 'Increment'"; + throw "Invalid value for badge, expected number or 'Increment' or {increment: number}"; } // Force filtering on only valid device tokens @@ -209,4 +211,5 @@ class PushController { } exports.PushController = PushController; -exports.default = PushController; \ No newline at end of file +exports.default = PushController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","buildRestWhere","then","write","RestWrite","restWhere","runOptions","many","execute","pushStatus","setInitial","objectId","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","catch","err","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      return badgeUpdate();\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file diff --git a/lib/Controllers/SchemaCache.js b/lib/Controllers/SchemaCache.js index 67982c4287..3e9fede799 100644 --- a/lib/Controllers/SchemaCache.js +++ b/lib/Controllers/SchemaCache.js @@ -93,4 +93,5 @@ class SchemaCache { }); } } -exports.default = SchemaCache; \ No newline at end of file +exports.default = SchemaCache; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Controllers/SchemaController.js b/lib/Controllers/SchemaController.js index ec89d50464..8375695153 100644 --- a/lib/Controllers/SchemaController.js +++ b/lib/Controllers/SchemaController.js @@ -519,6 +519,8 @@ class SchemaController { delete existingFields._rperm; delete existingFields._wperm; const newSchema = buildMergedSchemaObject(existingFields, submittedFields); + const defaultFields = defaultColumns[className] || defaultColumns._Default; + const fullNewSchema = Object.assign({}, newSchema, defaultFields); const validationError = this.validateSchemaData(className, newSchema, classLevelPermissions, Object.keys(existingFields)); if (validationError) { throw new Parse.Error(validationError.code, validationError.error); @@ -548,7 +550,7 @@ class SchemaController { return this.enforceFieldExists(className, fieldName, type); }); return Promise.all(promises); - }).then(() => this.setPermissions(className, classLevelPermissions, newSchema)).then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, newSchema)).then(() => this.reloadData({ clearCache: true })) + }).then(() => this.setPermissions(className, classLevelPermissions, newSchema)).then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, fullNewSchema)).then(() => this.reloadData({ clearCache: true })) //TODO: Move this logic into the database adapter .then(() => { const reloadedSchema = { @@ -1073,4 +1075,5 @@ exports.systemClasses = systemClasses; exports.defaultColumns = defaultColumns; exports.convertSchemaToAdapterSchema = convertSchemaToAdapterSchema; exports.VolatileClassesSchemas = VolatileClassesSchemas; -exports.SchemaController = SchemaController; \ No newline at end of file +exports.SchemaController = SchemaController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/SchemaController.js"],"names":["Parse","require","defaultColumns","Object","freeze","_Default","type","_User","_Installation","_Role","targetClass","_Session","_Product","_PushStatus","_JobStatus","_JobSchedule","_Hooks","_GlobalConfig","_Audience","_ExportProgress","requiredColumns","systemClasses","volatileClasses","userIdRegex","roleRegex","publicRegex","requireAuthenticationRegex","permissionKeyRegex","verifyPermissionKey","key","result","reduce","isGood","regEx","match","Error","INVALID_JSON","CLPValidKeys","validateCLP","perms","fields","keys","forEach","operation","indexOf","Array","isArray","perm","joinClassRegex","classAndFieldRegex","classNameIsValid","className","test","fieldNameIsValid","fieldName","fieldNameIsValidForClass","invalidClassNameMessage","invalidJsonError","validNonRelationOrPointerTypes","fieldTypeIsInvalid","INVALID_CLASS_NAME","undefined","INCORRECT_TYPE","convertSchemaToAdapterSchema","schema","injectDefaultSchema","ACL","_rperm","_wperm","password","_hashed_password","convertAdapterSchemaToParseSchema","authData","indexes","length","classLevelPermissions","defaultSchema","_HooksSchema","_GlobalConfigSchema","_PushStatusSchema","_JobStatusSchema","_JobScheduleSchema","_AudienceSchema","VolatileClassesSchemas","dbTypeMatchesObjectType","dbType","objectType","typeToString","SchemaController","constructor","databaseAdapter","schemaCache","_dbAdapter","_cache","data","reloadData","options","clearCache","promise","Promise","resolve","then","clear","reloadDataPromise","getAllClasses","allSchemas","err","allClasses","map","setAllClasses","getOneSchema","allowVolatileClasses","cached","getClass","setOneSchema","addClassIfNotExists","validationError","validateNewClass","reject","createClass","res","catch","error","code","DUPLICATE_VALUE","updateClass","submittedFields","database","existingFields","name","field","__op","newSchema","buildMergedSchemaObject","defaultFields","fullNewSchema","assign","validateSchemaData","deletedFields","insertedFields","push","deletePromise","deleteFields","promises","enforceFieldExists","all","setPermissions","setIndexesWithSchemaFormat","reloadedSchema","enforceClassExists","existingFieldNames","INVALID_KEY_NAME","message","geoPoints","filter","setClassLevelPermissions","split","expectedType","getExpectedType","addFieldIfNotExists","deleteField","fieldNames","schemaFields","adapter","deleteClass","validateObject","object","query","geocount","expected","getType","thenValidateRequiredColumns","validateRequiredColumns","columns","missingColumns","column","objectId","testBaseCLP","aclGroup","classPerms","some","acl","validatePermission","OBJECT_NOT_FOUND","permissionField","OPERATION_FORBIDDEN","hasClass","load","dbAdapter","putRequest","sysSchemaField","_id","oldField","fieldIsDeleted","newField","schemaPromise","obj","getObjectType","__type","iso","latitude","longitude","base64","coordinates","objects","ops"],"mappings":"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","file":"SchemaController.js","sourcesContent":["// @flow\n// This class handles schema validation, persistence, and modification.\n//\n// Each individual Schema object should be immutable. The helpers to\n// do things with the Schema just return a new schema when the schema\n// is changed.\n//\n// The canonical place to store this Schema is in the database itself,\n// in a _SCHEMA collection. This is not the right way to do it for an\n// open source framework, but it's backward compatible, so we're\n// keeping it this way for now.\n//\n// In API-handling code, you should only use the Schema class via the\n// DatabaseController. This will let us replace the schema logic for\n// different databases.\n// TODO: hide all schema logic inside the database adapter.\n// @flow-disable-next\nconst Parse = require('parse/node').Parse;\nimport { StorageAdapter }     from '../Adapters/Storage/StorageAdapter';\nimport DatabaseController     from './DatabaseController';\nimport type {\n  Schema,\n  SchemaFields,\n  ClassLevelPermissions,\n  SchemaField,\n  LoadSchemaOptions,\n} from './types';\n\nconst defaultColumns: {[string]: SchemaFields} = Object.freeze({\n  // Contain the default columns for every parse object type (except _Join collection)\n  _Default: {\n    \"objectId\":  {type:'String'},\n    \"createdAt\": {type:'Date'},\n    \"updatedAt\": {type:'Date'},\n    \"ACL\":       {type:'ACL'},\n  },\n  // The additional default columns for the _User collection (in addition to DefaultCols)\n  _User: {\n    \"username\":      {type:'String'},\n    \"password\":      {type:'String'},\n    \"email\":         {type:'String'},\n    \"emailVerified\": {type:'Boolean'},\n    \"authData\":      {type:'Object'}\n  },\n  // The additional default columns for the _Installation collection (in addition to DefaultCols)\n  _Installation: {\n    \"installationId\":   {type:'String'},\n    \"deviceToken\":      {type:'String'},\n    \"channels\":         {type:'Array'},\n    \"deviceType\":       {type:'String'},\n    \"pushType\":         {type:'String'},\n    \"GCMSenderId\":      {type:'String'},\n    \"timeZone\":         {type:'String'},\n    \"localeIdentifier\": {type:'String'},\n    \"badge\":            {type:'Number'},\n    \"appVersion\":       {type:'String'},\n    \"appName\":          {type:'String'},\n    \"appIdentifier\":    {type:'String'},\n    \"parseVersion\":     {type:'String'},\n  },\n  // The additional default columns for the _Role collection (in addition to DefaultCols)\n  _Role: {\n    \"name\":  {type:'String'},\n    \"users\": {type:'Relation', targetClass:'_User'},\n    \"roles\": {type:'Relation', targetClass:'_Role'}\n  },\n  // The additional default columns for the _Session collection (in addition to DefaultCols)\n  _Session: {\n    \"restricted\":     {type:'Boolean'},\n    \"user\":           {type:'Pointer', targetClass:'_User'},\n    \"installationId\": {type:'String'},\n    \"sessionToken\":   {type:'String'},\n    \"expiresAt\":      {type:'Date'},\n    \"createdWith\":    {type:'Object'}\n  },\n  _Product: {\n    \"productIdentifier\":  {type:'String'},\n    \"download\":           {type:'File'},\n    \"downloadName\":       {type:'String'},\n    \"icon\":               {type:'File'},\n    \"order\":              {type:'Number'},\n    \"title\":              {type:'String'},\n    \"subtitle\":           {type:'String'},\n  },\n  _PushStatus: {\n    \"pushTime\":            {type:'String'},\n    \"source\":              {type:'String'}, // rest or webui\n    \"query\":               {type:'String'}, // the stringified JSON query\n    \"payload\":             {type:'String'}, // the stringified JSON payload,\n    \"title\":               {type:'String'},\n    \"expiry\":              {type:'Number'},\n    \"expiration_interval\": {type:'Number'},\n    \"status\":              {type:'String'},\n    \"numSent\":             {type:'Number'},\n    \"numFailed\":           {type:'Number'},\n    \"pushHash\":            {type:'String'},\n    \"errorMessage\":        {type:'Object'},\n    \"sentPerType\":         {type:'Object'},\n    \"failedPerType\":       {type:'Object'},\n    \"sentPerUTCOffset\":    {type:'Object'},\n    \"failedPerUTCOffset\":  {type:'Object'},\n    \"count\":               {type:'Number'} // tracks # of batches queued and pending\n  },\n  _JobStatus: {\n    \"jobName\":    {type: 'String'},\n    \"source\":     {type: 'String'},\n    \"status\":     {type: 'String'},\n    \"message\":    {type: 'String'},\n    \"params\":     {type: 'Object'}, // params received when calling the job\n    \"finishedAt\": {type: 'Date'}\n  },\n  _JobSchedule: {\n    \"jobName\":      {type:'String'},\n    \"description\":  {type:'String'},\n    \"params\":       {type:'String'},\n    \"startAfter\":   {type:'String'},\n    \"daysOfWeek\":   {type:'Array'},\n    \"timeOfDay\":    {type:'String'},\n    \"lastRun\":      {type:'Number'},\n    \"repeatMinutes\":{type:'Number'}\n  },\n  _Hooks: {\n    \"functionName\": {type:'String'},\n    \"className\":    {type:'String'},\n    \"triggerName\":  {type:'String'},\n    \"url\":          {type:'String'}\n  },\n  _GlobalConfig: {\n    \"objectId\": {type: 'String'},\n    \"params\":   {type: 'Object'}\n  },\n  _Audience: {\n    \"objectId\":  {type:'String'},\n    \"name\":      {type:'String'},\n    \"query\":     {type:'String'}, //storing query as JSON string to prevent \"Nested keys should not contain the '$' or '.' characters\" error\n    \"lastUsed\":  {type:'Date'},\n    \"timesUsed\": {type:'Number'}\n  },\n  _ExportProgress: {\n    \"objectId\":      {type:'String'},\n    \"id\":            {type:'String'},\n    \"masterKey\":     {type:'String'},\n    \"applicationId\": {type:'String'}\n  }\n});\n\nconst requiredColumns = Object.freeze({\n  _Product: [\"productIdentifier\", \"icon\", \"order\", \"title\", \"subtitle\"],\n  _Role: [\"name\", \"ACL\"]\n});\n\nconst systemClasses = Object.freeze(['_User', '_Installation', '_Role', '_Session', '_Product', '_PushStatus', '_JobStatus', '_JobSchedule', '_Audience',  '_ExportProgress' ]);\n\nconst volatileClasses = Object.freeze(['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule', '_Audience', '_ExportProgress']);\n\n// 10 alpha numberic chars + uppercase\nconst userIdRegex = /^[a-zA-Z0-9]{10}$/;\n// Anything that start with role\nconst roleRegex = /^role:.*/;\n// * permission\nconst publicRegex = /^\\*$/\n\nconst requireAuthenticationRegex = /^requiresAuthentication$/\n\nconst permissionKeyRegex = Object.freeze([userIdRegex, roleRegex, publicRegex, requireAuthenticationRegex]);\n\nfunction verifyPermissionKey(key) {\n  const result = permissionKeyRegex.reduce((isGood, regEx) => {\n    isGood = isGood || key.match(regEx) != null;\n    return isGood;\n  }, false);\n  if (!result) {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid key for class level permissions`);\n  }\n}\n\nconst CLPValidKeys = Object.freeze(['find', 'count', 'get', 'create', 'update', 'delete', 'addField', 'readUserFields', 'writeUserFields']);\nfunction validateCLP(perms: ClassLevelPermissions, fields: SchemaFields) {\n  if (!perms) {\n    return;\n  }\n  Object.keys(perms).forEach((operation) => {\n    if (CLPValidKeys.indexOf(operation) == -1) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, `${operation} is not a valid operation for class level permissions`);\n    }\n    if (!perms[operation]) {\n      return;\n    }\n\n    if (operation === 'readUserFields' || operation === 'writeUserFields') {\n      if (!Array.isArray(perms[operation])) {\n        // @flow-disable-next\n        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perms[operation]}' is not a valid value for class level permissions ${operation}`);\n      } else {\n        perms[operation].forEach((key) => {\n          if (!fields[key] || fields[key].type != 'Pointer' || fields[key].targetClass != '_User') {\n            throw new Parse.Error(Parse.Error.INVALID_JSON, `'${key}' is not a valid column for class level pointer permissions ${operation}`);\n          }\n        });\n      }\n      return;\n    }\n\n    // @flow-disable-next\n    Object.keys(perms[operation]).forEach((key) => {\n      verifyPermissionKey(key);\n      // @flow-disable-next\n      const perm = perms[operation][key];\n      if (perm !== true) {\n        // @flow-disable-next\n        throw new Parse.Error(Parse.Error.INVALID_JSON, `'${perm}' is not a valid value for class level permissions ${operation}:${key}:${perm}`);\n      }\n    });\n  });\n}\nconst joinClassRegex = /^_Join:[A-Za-z0-9_]+:[A-Za-z0-9_]+/;\nconst classAndFieldRegex = /^[A-Za-z][A-Za-z0-9_]*$/;\nfunction classNameIsValid(className: string): boolean {\n  // Valid classes must:\n  return (\n    // Be one of _User, _Installation, _Role, _Session OR\n    systemClasses.indexOf(className) > -1 ||\n    // Be a join table OR\n    joinClassRegex.test(className) ||\n    // Include only alpha-numeric and underscores, and not start with an underscore or number\n    fieldNameIsValid(className)\n  );\n}\n\n// Valid fields must be alpha-numeric, and not start with an underscore or number\nfunction fieldNameIsValid(fieldName: string): boolean {\n  return classAndFieldRegex.test(fieldName);\n}\n\n// Checks that it's not trying to clobber one of the default fields of the class.\nfunction fieldNameIsValidForClass(fieldName: string, className: string): boolean {\n  if (!fieldNameIsValid(fieldName)) {\n    return false;\n  }\n  if (defaultColumns._Default[fieldName]) {\n    return false;\n  }\n  if (defaultColumns[className] && defaultColumns[className][fieldName]) {\n    return false;\n  }\n  return true;\n}\n\nfunction invalidClassNameMessage(className: string): string {\n  return 'Invalid classname: ' + className + ', classnames can only have alphanumeric characters and _, and must start with an alpha character ';\n}\n\nconst invalidJsonError = new Parse.Error(Parse.Error.INVALID_JSON, \"invalid JSON\");\nconst validNonRelationOrPointerTypes = [\n  'Number',\n  'String',\n  'Boolean',\n  'Date',\n  'Object',\n  'Array',\n  'GeoPoint',\n  'File',\n  'Bytes',\n  'Polygon'\n];\n// Returns an error suitable for throwing if the type is invalid\nconst fieldTypeIsInvalid = ({ type, targetClass }) => {\n  if (['Pointer', 'Relation'].indexOf(type) >= 0) {\n    if (!targetClass) {\n      return new Parse.Error(135, `type ${type} needs a class name`);\n    } else if (typeof targetClass !== 'string') {\n      return invalidJsonError;\n    } else if (!classNameIsValid(targetClass)) {\n      return new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(targetClass));\n    } else {\n      return undefined;\n    }\n  }\n  if (typeof type !== 'string') {\n    return invalidJsonError;\n  }\n  if (validNonRelationOrPointerTypes.indexOf(type) < 0) {\n    return new Parse.Error(Parse.Error.INCORRECT_TYPE, `invalid field type: ${type}`);\n  }\n  return undefined;\n}\n\nconst convertSchemaToAdapterSchema = (schema: any) => {\n  schema = injectDefaultSchema(schema);\n  delete schema.fields.ACL;\n  schema.fields._rperm = { type: 'Array' };\n  schema.fields._wperm = { type: 'Array' };\n\n  if (schema.className === '_User') {\n    delete schema.fields.password;\n    schema.fields._hashed_password = { type: 'String' };\n  }\n\n  return schema;\n}\n\nconst convertAdapterSchemaToParseSchema = ({...schema}) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  schema.fields.ACL = { type: 'ACL' };\n\n  if (schema.className === '_User') {\n    delete schema.fields.authData; //Auth data is implicit\n    delete schema.fields._hashed_password;\n    schema.fields.password = { type: 'String' };\n  }\n\n  if (schema.indexes && Object.keys(schema.indexes).length === 0) {\n    delete schema.indexes;\n  }\n\n  return schema;\n}\n\nconst injectDefaultSchema = ({className, fields, classLevelPermissions, indexes}: Schema) => {\n  const defaultSchema: Schema = {\n    className,\n    fields: {\n      ...defaultColumns._Default,\n      ...(defaultColumns[className] || {}),\n      ...fields,\n    },\n    classLevelPermissions,\n  };\n  if (indexes && Object.keys(indexes).length !== 0) {\n    defaultSchema.indexes = indexes;\n  }\n  return defaultSchema;\n};\n\nconst _HooksSchema =  {className: \"_Hooks\", fields: defaultColumns._Hooks};\nconst _GlobalConfigSchema = { className: \"_GlobalConfig\", fields: defaultColumns._GlobalConfig }\nconst _PushStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_PushStatus\",\n  fields: {},\n  classLevelPermissions: {}\n}));\nconst _JobStatusSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_JobStatus\",\n  fields: {},\n  classLevelPermissions: {}\n}));\nconst _JobScheduleSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_JobSchedule\",\n  fields: {},\n  classLevelPermissions: {}\n}));\nconst _AudienceSchema = convertSchemaToAdapterSchema(injectDefaultSchema({\n  className: \"_Audience\",\n  fields: defaultColumns._Audience,\n  classLevelPermissions: {}\n}));\nconst VolatileClassesSchemas = [_HooksSchema, _JobStatusSchema, _JobScheduleSchema, _PushStatusSchema, _GlobalConfigSchema, _AudienceSchema];\n\nconst dbTypeMatchesObjectType = (dbType: SchemaField | string, objectType: SchemaField) => {\n  if (dbType.type !== objectType.type) return false;\n  if (dbType.targetClass !== objectType.targetClass) return false;\n  if (dbType === objectType.type) return true;\n  if (dbType.type === objectType.type) return true;\n  return false;\n}\n\nconst typeToString = (type: SchemaField | string): string => {\n  if (typeof type === 'string') {\n    return type;\n  }\n  if (type.targetClass) {\n    return `${type.type}<${type.targetClass}>`;\n  }\n  return `${type.type}`;\n}\n\n// Stores the entire schema of the app in a weird hybrid format somewhere between\n// the mongo format and the Parse format. Soon, this will all be Parse format.\nexport default class SchemaController {\n  _dbAdapter: StorageAdapter;\n  data: any;\n  perms: any;\n  indexes: any;\n  _cache: any;\n  reloadDataPromise: Promise<any>;\n\n  constructor(databaseAdapter: StorageAdapter, schemaCache: any) {\n    this._dbAdapter = databaseAdapter;\n    this._cache = schemaCache;\n    // this.data[className][fieldName] tells you the type of that field, in mongo format\n    this.data = {};\n    // this.perms[className][operation] tells you the acl-style permissions\n    this.perms = {};\n    // this.indexes[className][operation] tells you the indexes\n    this.indexes = {};\n  }\n\n  reloadData(options: LoadSchemaOptions = {clearCache: false}): Promise<any> {\n    let promise = Promise.resolve();\n    if (options.clearCache) {\n      promise = promise.then(() => {\n        return this._cache.clear();\n      });\n    }\n    if (this.reloadDataPromise && !options.clearCache) {\n      return this.reloadDataPromise;\n    }\n    this.reloadDataPromise = promise.then(() => {\n      return this.getAllClasses(options).then((allSchemas) => {\n        const data = {};\n        const perms = {};\n        const indexes = {};\n        allSchemas.forEach(schema => {\n          data[schema.className] = injectDefaultSchema(schema).fields;\n          perms[schema.className] = schema.classLevelPermissions;\n          indexes[schema.className] = schema.indexes;\n        });\n\n        // Inject the in-memory classes\n        volatileClasses.forEach(className => {\n          const schema = injectDefaultSchema({ className, fields: {}, classLevelPermissions: {} });\n          data[className] = schema.fields;\n          perms[className] = schema.classLevelPermissions;\n          indexes[className] = schema.indexes;\n        });\n        this.data = data;\n        this.perms = perms;\n        this.indexes = indexes;\n        delete this.reloadDataPromise;\n      }, (err) => {\n        this.data = {};\n        this.perms = {};\n        this.indexes = {};\n        delete this.reloadDataPromise;\n        throw err;\n      })\n    }).then(() => {});\n    return this.reloadDataPromise;\n  }\n\n  getAllClasses(options: LoadSchemaOptions = {clearCache: false}): Promise<Array<Schema>> {\n    let promise = Promise.resolve();\n    if (options.clearCache) {\n      promise = this._cache.clear();\n    }\n    return promise.then(() => {\n      return this._cache.getAllClasses()\n    }).then((allClasses) => {\n      if (allClasses && allClasses.length && !options.clearCache) {\n        return Promise.resolve(allClasses);\n      }\n      return this._dbAdapter.getAllClasses()\n        .then(allSchemas => allSchemas.map(injectDefaultSchema))\n        .then(allSchemas => {\n          return this._cache.setAllClasses(allSchemas).then(() => {\n            return allSchemas;\n          });\n        })\n    });\n  }\n\n  getOneSchema(className: string, allowVolatileClasses: boolean = false, options: LoadSchemaOptions = {clearCache: false}): Promise<Schema> {\n    let promise = Promise.resolve();\n    if (options.clearCache) {\n      promise = this._cache.clear();\n    }\n    return promise.then(() => {\n      if (allowVolatileClasses && volatileClasses.indexOf(className) > -1) {\n        return Promise.resolve({\n          className,\n          fields: this.data[className],\n          classLevelPermissions: this.perms[className],\n          indexes: this.indexes[className]\n        });\n      }\n      return this._cache.getOneSchema(className).then((cached) => {\n        if (cached && !options.clearCache) {\n          return Promise.resolve(cached);\n        }\n        return this._dbAdapter.getClass(className)\n          .then(injectDefaultSchema)\n          .then((result) => {\n            return this._cache.setOneSchema(className, result).then(() => {\n              return result;\n            })\n          });\n      });\n    });\n  }\n\n  // Create a new class that includes the three default fields.\n  // ACL is an implicit column that does not get an entry in the\n  // _SCHEMAS database. Returns a promise that resolves with the\n  // created schema, in mongo format.\n  // on success, and rejects with an error on fail. Ensure you\n  // have authorization (master key, or client class creation\n  // enabled) before calling this function.\n  addClassIfNotExists(className: string, fields: SchemaFields = {}, classLevelPermissions: any, indexes: any = {}): Promise<void> {\n    var validationError = this.validateNewClass(className, fields, classLevelPermissions);\n    if (validationError) {\n      return Promise.reject(validationError);\n    }\n\n    return this._dbAdapter.createClass(className, convertSchemaToAdapterSchema({ fields, classLevelPermissions, indexes, className }))\n      .then(convertAdapterSchemaToParseSchema)\n      .then((res) => {\n        return this._cache.clear().then(() => {\n          return Promise.resolve(res);\n        });\n      })\n      .catch(error => {\n        if (error && error.code === Parse.Error.DUPLICATE_VALUE) {\n          throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);\n        } else {\n          throw error;\n        }\n      });\n  }\n\n  updateClass(className: string, submittedFields: SchemaFields, classLevelPermissions: any, indexes: any, database: DatabaseController) {\n    return this.getOneSchema(className)\n      .then(schema => {\n        const existingFields = schema.fields;\n        Object.keys(submittedFields).forEach(name => {\n          const field = submittedFields[name];\n          if (existingFields[name] && field.__op !== 'Delete') {\n            throw new Parse.Error(255, `Field ${name} exists, cannot update.`);\n          }\n          if (!existingFields[name] && field.__op === 'Delete') {\n            throw new Parse.Error(255, `Field ${name} does not exist, cannot delete.`);\n          }\n        });\n\n        delete existingFields._rperm;\n        delete existingFields._wperm;\n        const newSchema = buildMergedSchemaObject(existingFields, submittedFields);\n        const defaultFields = defaultColumns[className] || defaultColumns._Default;\n        const fullNewSchema = Object.assign({}, newSchema, defaultFields);\n        const validationError = this.validateSchemaData(className, newSchema, classLevelPermissions, Object.keys(existingFields));\n        if (validationError) {\n          throw new Parse.Error(validationError.code, validationError.error);\n        }\n\n        // Finally we have checked to make sure the request is valid and we can start deleting fields.\n        // Do all deletions first, then a single save to _SCHEMA collection to handle all additions.\n        const deletedFields: string[] = [];\n        const insertedFields = [];\n        Object.keys(submittedFields).forEach(fieldName => {\n          if (submittedFields[fieldName].__op === 'Delete') {\n            deletedFields.push(fieldName);\n          } else {\n            insertedFields.push(fieldName);\n          }\n        });\n\n        let deletePromise = Promise.resolve();\n        if (deletedFields.length > 0) {\n          deletePromise = this.deleteFields(deletedFields, className, database);\n        }\n        return deletePromise // Delete Everything\n          .then(() => this.reloadData({ clearCache: true })) // Reload our Schema, so we have all the new values\n          .then(() => {\n            const promises = insertedFields.map(fieldName => {\n              const type = submittedFields[fieldName];\n              return this.enforceFieldExists(className, fieldName, type);\n            });\n            return Promise.all(promises);\n          })\n          .then(() => this.setPermissions(className, classLevelPermissions, newSchema))\n          .then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, fullNewSchema))\n          .then(() => this.reloadData({ clearCache: true }))\n        //TODO: Move this logic into the database adapter\n          .then(() => {\n            const reloadedSchema: Schema = {\n              className: className,\n              fields: this.data[className],\n              classLevelPermissions: this.perms[className],\n            };\n            if (this.indexes[className] && Object.keys(this.indexes[className]).length !== 0) {\n              reloadedSchema.indexes = this.indexes[className];\n            }\n            return reloadedSchema;\n          });\n      })\n      .catch(error => {\n        if (error === undefined) {\n          throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);\n        } else {\n          throw error;\n        }\n      })\n  }\n\n  // Returns a promise that resolves successfully to the new schema\n  // object or fails with a reason.\n  enforceClassExists(className: string): Promise<SchemaController> {\n    if (this.data[className]) {\n      return Promise.resolve(this);\n    }\n    // We don't have this class. Update the schema\n    return this.addClassIfNotExists(className)\n    // The schema update succeeded. Reload the schema\n      .then(() => this.reloadData({ clearCache: true }))\n      .catch(() => {\n      // The schema update failed. This can be okay - it might\n      // have failed because there's a race condition and a different\n      // client is making the exact same schema update that we want.\n      // So just reload the schema.\n        return this.reloadData({ clearCache: true });\n      })\n      .then(() => {\n      // Ensure that the schema now validates\n        if (this.data[className]) {\n          return this;\n        } else {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, `Failed to add ${className}`);\n        }\n      })\n      .catch(() => {\n      // The schema still doesn't validate. Give up\n        throw new Parse.Error(Parse.Error.INVALID_JSON, 'schema class name does not revalidate');\n      });\n  }\n\n  validateNewClass(className: string, fields: SchemaFields = {}, classLevelPermissions: any): any {\n    if (this.data[className]) {\n      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} already exists.`);\n    }\n    if (!classNameIsValid(className)) {\n      return {\n        code: Parse.Error.INVALID_CLASS_NAME,\n        error: invalidClassNameMessage(className),\n      };\n    }\n    return this.validateSchemaData(className, fields, classLevelPermissions, []);\n  }\n\n  validateSchemaData(className: string, fields: SchemaFields, classLevelPermissions: ClassLevelPermissions, existingFieldNames: Array<string>) {\n    for (const fieldName in fields) {\n      if (existingFieldNames.indexOf(fieldName) < 0) {\n        if (!fieldNameIsValid(fieldName)) {\n          return {\n            code: Parse.Error.INVALID_KEY_NAME,\n            error: 'invalid field name: ' + fieldName,\n          };\n        }\n        if (!fieldNameIsValidForClass(fieldName, className)) {\n          return {\n            code: 136,\n            error: 'field ' + fieldName + ' cannot be added',\n          };\n        }\n        const error = fieldTypeIsInvalid(fields[fieldName]);\n        if (error) return { code: error.code, error: error.message };\n      }\n    }\n\n    for (const fieldName in defaultColumns[className]) {\n      fields[fieldName] = defaultColumns[className][fieldName];\n    }\n\n    const geoPoints = Object.keys(fields).filter(key => fields[key] && fields[key].type === 'GeoPoint');\n    if (geoPoints.length > 1) {\n      return {\n        code: Parse.Error.INCORRECT_TYPE,\n        error: 'currently, only one GeoPoint field may exist in an object. Adding ' + geoPoints[1] + ' when ' + geoPoints[0] + ' already exists.',\n      };\n    }\n    validateCLP(classLevelPermissions, fields);\n  }\n\n  // Sets the Class-level permissions for a given className, which must exist.\n  setPermissions(className: string, perms: any, newSchema: SchemaFields) {\n    if (typeof perms === 'undefined') {\n      return Promise.resolve();\n    }\n    validateCLP(perms, newSchema);\n    return this._dbAdapter.setClassLevelPermissions(className, perms);\n  }\n\n  // Returns a promise that resolves successfully to the new schema\n  // object if the provided className-fieldName-type tuple is valid.\n  // The className must already be validated.\n  // If 'freeze' is true, refuse to update the schema for this field.\n  enforceFieldExists(className: string, fieldName: string, type: string | SchemaField) {\n    if (fieldName.indexOf(\".\") > 0) {\n      // subdocument key (x.y) => ok if x is of type 'object'\n      fieldName = fieldName.split(\".\")[ 0 ];\n      type = 'Object';\n    }\n    if (!fieldNameIsValid(fieldName)) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`);\n    }\n\n    // If someone tries to create a new field with null/undefined as the value, return;\n    if (!type) {\n      return Promise.resolve(this);\n    }\n\n    return this.reloadData().then(() => {\n      const expectedType = this.getExpectedType(className, fieldName);\n      if (typeof type === 'string') {\n        type = { type };\n      }\n\n      if (expectedType) {\n        if (!dbTypeMatchesObjectType(expectedType, type)) {\n          throw new Parse.Error(\n            Parse.Error.INCORRECT_TYPE,\n            `schema mismatch for ${className}.${fieldName}; expected ${typeToString(expectedType)} but got ${typeToString(type)}`\n          );\n        }\n        return this;\n      }\n\n      return this._dbAdapter.addFieldIfNotExists(className, fieldName, type).then(() => {\n        // The update succeeded. Reload the schema\n        return this.reloadData({ clearCache: true });\n      }, (error) => {\n        if (error.code == Parse.Error.INCORRECT_TYPE) {\n          // Make sure that we throw errors when it is appropriate to do so.\n          throw error;\n        }\n        // The update failed. This can be okay - it might have been a race\n        // condition where another client updated the schema in the same\n        // way that we wanted to. So, just reload the schema\n        return this.reloadData({ clearCache: true });\n      }).then(() => {\n        // Ensure that the schema now validates\n        const expectedType = this.getExpectedType(className, fieldName);\n        if (typeof type === 'string') {\n          type = { type };\n        }\n        if (!expectedType || !dbTypeMatchesObjectType(expectedType, type)) {\n          throw new Parse.Error(Parse.Error.INVALID_JSON, `Could not add field ${fieldName}`);\n        }\n        // Remove the cached schema\n        this._cache.clear();\n        return this;\n      });\n    });\n  }\n\n  // maintain compatibility\n  deleteField(fieldName: string, className: string, database: DatabaseController) {\n    return this.deleteFields([fieldName], className, database);\n  }\n\n  // Delete fields, and remove that data from all objects. This is intended\n  // to remove unused fields, if other writers are writing objects that include\n  // this field, the field may reappear. Returns a Promise that resolves with\n  // no object on success, or rejects with { code, error } on failure.\n  // Passing the database and prefix is necessary in order to drop relation collections\n  // and remove fields from objects. Ideally the database would belong to\n  // a database adapter and this function would close over it or access it via member.\n  deleteFields(fieldNames: Array<string>, className: string, database: DatabaseController) {\n    if (!classNameIsValid(className)) {\n      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, invalidClassNameMessage(className));\n    }\n\n    fieldNames.forEach(fieldName => {\n      if (!fieldNameIsValid(fieldName)) {\n        throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `invalid field name: ${fieldName}`);\n      }\n      //Don't allow deleting the default fields.\n      if (!fieldNameIsValidForClass(fieldName, className)) {\n        throw new Parse.Error(136, `field ${fieldName} cannot be changed`);\n      }\n    });\n\n    return this.getOneSchema(className, false, {clearCache: true})\n      .catch(error => {\n        if (error === undefined) {\n          throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);\n        } else {\n          throw error;\n        }\n      })\n      .then(schema => {\n        fieldNames.forEach(fieldName => {\n          if (!schema.fields[fieldName]) {\n            throw new Parse.Error(255, `Field ${fieldName} does not exist, cannot delete.`);\n          }\n        });\n\n        const schemaFields = { ...schema.fields };\n        return database.adapter.deleteFields(className, schema, fieldNames)\n          .then(() => {\n            return Promise.all(fieldNames.map(fieldName => {\n              const field = schemaFields[fieldName];\n              if (field && field.type === 'Relation') {\n              //For relations, drop the _Join table\n                return database.adapter.deleteClass(`_Join:${fieldName}:${className}`);\n              }\n              return Promise.resolve();\n            }));\n          });\n      }).then(() => {\n        this._cache.clear();\n      });\n  }\n\n  // Validates an object provided in REST format.\n  // Returns a promise that resolves to the new schema if this object is\n  // valid.\n  validateObject(className: string, object: any, query: any) {\n    let geocount = 0;\n    let promise = this.enforceClassExists(className);\n    for (const fieldName in object) {\n      if (object[fieldName] === undefined) {\n        continue;\n      }\n      const expected = getType(object[fieldName]);\n      if (expected === 'GeoPoint') {\n        geocount++;\n      }\n      if (geocount > 1) {\n        // Make sure all field validation operations run before we return.\n        // If not - we are continuing to run logic, but already provided response from the server.\n        return promise.then(() => {\n          return Promise.reject(new Parse.Error(Parse.Error.INCORRECT_TYPE,\n            'there can only be one geopoint field in a class'));\n        });\n      }\n      if (!expected) {\n        continue;\n      }\n      if (fieldName === 'ACL') {\n        // Every object has ACL implicitly.\n        continue;\n      }\n\n      promise = promise.then(schema => schema.enforceFieldExists(className, fieldName, expected));\n    }\n    promise = thenValidateRequiredColumns(promise, className, object, query);\n    return promise;\n  }\n\n  // Validates that all the properties are set for the object\n  validateRequiredColumns(className: string, object: any, query: any) {\n    const columns = requiredColumns[className];\n    if (!columns || columns.length == 0) {\n      return Promise.resolve(this);\n    }\n\n    const missingColumns = columns.filter(function(column){\n      if (query && query.objectId) {\n        if (object[column] && typeof object[column] === \"object\") {\n          // Trying to delete a required column\n          return object[column].__op == 'Delete';\n        }\n        // Not trying to do anything there\n        return false;\n      }\n      return !object[column]\n    });\n\n    if (missingColumns.length > 0) {\n      throw new Parse.Error(\n        Parse.Error.INCORRECT_TYPE,\n        missingColumns[0] + ' is required.');\n    }\n    return Promise.resolve(this);\n  }\n\n  // Validates the base CLP for an operation\n  testBaseCLP(className: string, aclGroup: string[], operation: string) {\n    if (!this.perms[className] || !this.perms[className][operation]) {\n      return true;\n    }\n    const classPerms = this.perms[className];\n    const perms = classPerms[operation];\n    // Handle the public scenario quickly\n    if (perms['*']) {\n      return true;\n    }\n    // Check permissions against the aclGroup provided (array of userId/roles)\n    if (aclGroup.some(acl => { return perms[acl] === true })) {\n      return true;\n    }\n    return false;\n  }\n\n  // Validates an operation passes class-level-permissions set in the schema\n  validatePermission(className: string, aclGroup: string[], operation: string) {\n\n    if (this.testBaseCLP(className, aclGroup, operation)) {\n      return Promise.resolve();\n    }\n\n    if (!this.perms[className] || !this.perms[className][operation]) {\n      return true;\n    }\n    const classPerms = this.perms[className];\n    const perms = classPerms[operation];\n\n    // If only for authenticated users\n    // make sure we have an aclGroup\n    if (perms['requiresAuthentication']) {\n      // If aclGroup has * (public)\n      if (!aclGroup || aclGroup.length == 0) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n          'Permission denied, user needs to be authenticated.');\n      } else if (aclGroup.indexOf('*') > -1 && aclGroup.length == 1) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n          'Permission denied, user needs to be authenticated.');\n      }\n      // requiresAuthentication passed, just move forward\n      // probably would be wise at some point to rename to 'authenticatedUser'\n      return Promise.resolve();\n    }\n\n    // No matching CLP, let's check the Pointer permissions\n    // And handle those later\n    const permissionField = ['get', 'find', 'count'].indexOf(operation) > -1 ? 'readUserFields' : 'writeUserFields';\n\n    // Reject create when write lockdown\n    if (permissionField == 'writeUserFields' && operation == 'create') {\n      throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n        `Permission denied for action ${operation} on class ${className}.`);\n    }\n\n    // Process the readUserFields later\n    if (Array.isArray(classPerms[permissionField]) && classPerms[permissionField].length > 0) {\n      return Promise.resolve();\n    }\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n      `Permission denied for action ${operation} on class ${className}.`);\n  }\n\n  // Returns the expected type for a className+key combination\n  // or undefined if the schema is not set\n  getExpectedType(className: string, fieldName: string): ?(SchemaField | string) {\n    if (this.data && this.data[className]) {\n      const expectedType = this.data[className][fieldName]\n      return expectedType === 'map' ? 'Object' : expectedType;\n    }\n    return undefined;\n  }\n\n  // Checks if a given class is in the schema.\n  hasClass(className: string) {\n    return this.reloadData().then(() => !!(this.data[className]));\n  }\n}\n\n// Returns a promise for a new Schema.\nconst load = (dbAdapter: StorageAdapter, schemaCache: any, options: any): Promise<SchemaController> => {\n  const schema = new SchemaController(dbAdapter, schemaCache);\n  return schema.reloadData(options).then(() => schema);\n}\n\n// Builds a new schema (in schema API response format) out of an\n// existing mongo schema + a schemas API put request. This response\n// does not include the default fields, as it is intended to be passed\n// to mongoSchemaFromFieldsAndClassName. No validation is done here, it\n// is done in mongoSchemaFromFieldsAndClassName.\nfunction buildMergedSchemaObject(existingFields: SchemaFields, putRequest: any): SchemaFields {\n  const newSchema = {};\n  // @flow-disable-next\n  const sysSchemaField = Object.keys(defaultColumns).indexOf(existingFields._id) === -1 ? [] : Object.keys(defaultColumns[existingFields._id]);\n  for (const oldField in existingFields) {\n    if (oldField !== '_id' && oldField !== 'ACL' &&  oldField !== 'updatedAt' && oldField !== 'createdAt' && oldField !== 'objectId') {\n      if (sysSchemaField.length > 0 && sysSchemaField.indexOf(oldField) !== -1) {\n        continue;\n      }\n      const fieldIsDeleted = putRequest[oldField] && putRequest[oldField].__op === 'Delete'\n      if (!fieldIsDeleted) {\n        newSchema[oldField] = existingFields[oldField];\n      }\n    }\n  }\n  for (const newField in putRequest) {\n    if (newField !== 'objectId' && putRequest[newField].__op !== 'Delete') {\n      if (sysSchemaField.length > 0 && sysSchemaField.indexOf(newField) !== -1) {\n        continue;\n      }\n      newSchema[newField] = putRequest[newField];\n    }\n  }\n  return newSchema;\n}\n\n// Given a schema promise, construct another schema promise that\n// validates this field once the schema loads.\nfunction thenValidateRequiredColumns(schemaPromise, className, object, query) {\n  return schemaPromise.then((schema) => {\n    return schema.validateRequiredColumns(className, object, query);\n  });\n}\n\n// Gets the type from a REST API formatted object, where 'type' is\n// extended past javascript types to include the rest of the Parse\n// type system.\n// The output should be a valid schema value.\n// TODO: ensure that this is compatible with the format used in Open DB\nfunction getType(obj: any): ?(SchemaField | string) {\n  const type = typeof obj;\n  switch(type) {\n  case 'boolean':\n    return 'Boolean';\n  case 'string':\n    return 'String';\n  case 'number':\n    return 'Number';\n  case 'map':\n  case 'object':\n    if (!obj) {\n      return undefined;\n    }\n    return getObjectType(obj);\n  case 'function':\n  case 'symbol':\n  case 'undefined':\n  default:\n    throw 'bad obj: ' + obj;\n  }\n}\n\n// This gets the type for non-JSON types like pointers and files, but\n// also gets the appropriate type for $ operators.\n// Returns null if the type is unknown.\nfunction getObjectType(obj): ?(SchemaField | string) {\n  if (obj instanceof Array) {\n    return 'Array';\n  }\n  if (obj.__type){\n    switch(obj.__type) {\n    case 'Pointer' :\n      if(obj.className) {\n        return {\n          type: 'Pointer',\n          targetClass: obj.className\n        }\n      }\n      break;\n    case 'Relation' :\n      if(obj.className) {\n        return {\n          type: 'Relation',\n          targetClass: obj.className\n        }\n      }\n      break;\n    case 'File' :\n      if(obj.name) {\n        return 'File';\n      }\n      break;\n    case 'Date' :\n      if(obj.iso) {\n        return 'Date';\n      }\n      break;\n    case 'GeoPoint' :\n      if(obj.latitude != null && obj.longitude != null) {\n        return 'GeoPoint';\n      }\n      break;\n    case 'Bytes' :\n      if(obj.base64) {\n        return 'Bytes';\n      }\n      break;\n    case 'Polygon' :\n      if(obj.coordinates) {\n        return 'Polygon';\n      }\n      break;\n    }\n    throw new Parse.Error(Parse.Error.INCORRECT_TYPE, \"This is not a valid \" + obj.__type);\n  }\n  if (obj['$ne']) {\n    return getObjectType(obj['$ne']);\n  }\n  if (obj.__op) {\n    switch(obj.__op) {\n    case 'Increment':\n      return 'Number';\n    case 'Delete':\n      return null;\n    case 'Add':\n    case 'AddUnique':\n    case 'Remove':\n      return 'Array';\n    case 'AddRelation':\n    case 'RemoveRelation':\n      return {\n        type: 'Relation',\n        targetClass: obj.objects[0].className\n      }\n    case 'Batch':\n      return getObjectType(obj.ops[0]);\n    default:\n      throw 'unexpected op: ' + obj.__op;\n    }\n  }\n  return 'Object';\n}\n\nexport {\n  load,\n  classNameIsValid,\n  fieldNameIsValid,\n  invalidClassNameMessage,\n  buildMergedSchemaObject,\n  systemClasses,\n  defaultColumns,\n  convertSchemaToAdapterSchema,\n  VolatileClassesSchemas,\n  SchemaController,\n};\n"]} \ No newline at end of file diff --git a/lib/Controllers/UserController.js b/lib/Controllers/UserController.js index 2ca5f18cf0..60b713fceb 100644 --- a/lib/Controllers/UserController.js +++ b/lib/Controllers/UserController.js @@ -266,4 +266,5 @@ function buildEmailLink(destination, username, token, config) { } } -exports.default = UserController; \ No newline at end of file +exports.default = UserController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/UserController.js"],"names":["RestQuery","require","Auth","UserController","AdaptableController","constructor","adapter","appId","options","validateAdapter","shouldVerifyEmails","expectedAdapterType","MailAdapter","verifyUserEmails","setEmailVerifyToken","user","_email_verify_token","emailVerified","config","emailVerifyTokenValidityDuration","_email_verify_token_expires_at","Parse","_encode","generateEmailVerifyTokenExpiresAt","verifyEmail","username","token","undefined","query","updateFields","__op","$gt","Date","masterAuth","master","checkIfAlreadyVerified","execute","then","result","results","length","Promise","resolve","rest","update","checkResetTokenValidity","database","find","_perishable_token","limit","passwordPolicy","resetTokenValidityDuration","expiresDate","_perishable_token_expires_at","__type","iso","getUserIfNeeded","email","where","sendVerificationEmail","encodeURIComponent","link","buildEmailLink","verifyEmailURL","appName","sendMail","defaultVerificationEmail","regenerateEmailVerifyToken","resendVerificationEmail","aUser","setPasswordResetToken","generatePasswordResetTokenExpiresAt","$or","$exists","sendPasswordResetEmail","requestResetPasswordURL","defaultResetPasswordEmail","updatePassword","password","updateUserPassword","objectId","catch","error","message","reject","text","get","to","subject","userId","destination","usernameAndToken","parseFrameURL","destinationWithoutHost","replace","publicServerURL"],"mappings":"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","file":"UserController.js","sourcesContent":["import { randomString }    from '../cryptoUtils';\nimport { inflate }         from '../triggers';\nimport AdaptableController from './AdaptableController';\nimport MailAdapter         from '../Adapters/Email/MailAdapter';\nimport rest                from '../rest';\nimport Parse               from 'parse/node';\n\nvar RestQuery = require('../RestQuery');\nvar Auth = require('../Auth');\n\nexport class UserController extends AdaptableController {\n\n  constructor(adapter, appId, options = {}) {\n    super(adapter, appId, options);\n  }\n\n  validateAdapter(adapter) {\n    // Allow no adapter\n    if (!adapter && !this.shouldVerifyEmails) {\n      return;\n    }\n    super.validateAdapter(adapter);\n  }\n\n  expectedAdapterType() {\n    return MailAdapter;\n  }\n\n  get shouldVerifyEmails() {\n    return this.options.verifyUserEmails;\n  }\n\n  setEmailVerifyToken(user) {\n    if (this.shouldVerifyEmails) {\n      user._email_verify_token = randomString(25);\n      user.emailVerified = false;\n\n      if (this.config.emailVerifyTokenValidityDuration) {\n        user._email_verify_token_expires_at = Parse._encode(this.config.generateEmailVerifyTokenExpiresAt());\n      }\n    }\n  }\n\n  verifyEmail(username, token) {\n    if (!this.shouldVerifyEmails) {\n      // Trying to verify email when not enabled\n      // TODO: Better error here.\n      throw undefined;\n    }\n\n    const query = {username: username, _email_verify_token: token};\n    const updateFields = { emailVerified: true, _email_verify_token: {__op: 'Delete'}};\n\n    // if the email verify token needs to be validated then\n    // add additional query params and additional fields that need to be updated\n    if (this.config.emailVerifyTokenValidityDuration) {\n      query.emailVerified = false;\n      query._email_verify_token_expires_at = { $gt: Parse._encode(new Date()) };\n\n      updateFields._email_verify_token_expires_at = {__op: 'Delete'};\n    }\n    const masterAuth = Auth.master(this.config);\n    var checkIfAlreadyVerified = new RestQuery(this.config, Auth.master(this.config), '_User', {username: username, emailVerified: true});\n    return checkIfAlreadyVerified.execute().then(result => {\n      if (result.results.length) {\n        return Promise.resolve(result.results.length[0]);\n      }\n      return rest.update(this.config, masterAuth, '_User', query, updateFields);\n    });\n  }\n\n  checkResetTokenValidity(username, token) {\n    return this.config.database.find('_User', {\n      username: username,\n      _perishable_token: token\n    }, {limit: 1}).then(results => {\n      if (results.length != 1) {\n        throw undefined;\n      }\n\n      if (this.config.passwordPolicy && this.config.passwordPolicy.resetTokenValidityDuration) {\n        let expiresDate = results[0]._perishable_token_expires_at;\n        if (expiresDate && expiresDate.__type == 'Date') {\n          expiresDate = new Date(expiresDate.iso);\n        }\n        if (expiresDate < new Date())\n          throw 'The password reset link has expired';\n      }\n\n      return results[0];\n    });\n  }\n\n  getUserIfNeeded(user) {\n    if (user.username && user.email) {\n      return Promise.resolve(user);\n    }\n    var where = {};\n    if (user.username) {\n      where.username = user.username;\n    }\n    if (user.email) {\n      where.email = user.email;\n    }\n\n    var query = new RestQuery(this.config, Auth.master(this.config), '_User', where);\n    return query.execute().then(function(result){\n      if (result.results.length != 1) {\n        throw undefined;\n      }\n      return result.results[0];\n    })\n  }\n\n  sendVerificationEmail(user) {\n    if (!this.shouldVerifyEmails) {\n      return;\n    }\n    const token = encodeURIComponent(user._email_verify_token);\n    // We may need to fetch the user in case of update email\n    this.getUserIfNeeded(user).then((user) => {\n      const username = encodeURIComponent(user.username);\n\n      const link = buildEmailLink(this.config.verifyEmailURL, username, token, this.config);\n      const options = {\n        appName: this.config.appName,\n        link: link,\n        user: inflate('_User', user),\n      };\n      if (this.adapter.sendVerificationEmail) {\n        this.adapter.sendVerificationEmail(options);\n      } else {\n        this.adapter.sendMail(this.defaultVerificationEmail(options));\n      }\n    });\n  }\n\n  /**\n   * Regenerates the given user's email verification token\n   *\n   * @param user\n   * @returns {*}\n   */\n  regenerateEmailVerifyToken(user) {\n    this.setEmailVerifyToken(user);\n    return this.config.database.update('_User', { username: user.username }, user);\n  }\n\n  resendVerificationEmail(username) {\n    return this.getUserIfNeeded({username: username}).then((aUser) => {\n      if (!aUser || aUser.emailVerified) {\n        throw undefined;\n      }\n      return this.regenerateEmailVerifyToken(aUser).then(() => {\n        this.sendVerificationEmail(aUser);\n      });\n    });\n  }\n\n  setPasswordResetToken(email) {\n    const token = { _perishable_token: randomString(25) };\n\n    if (this.config.passwordPolicy && this.config.passwordPolicy.resetTokenValidityDuration) {\n      token._perishable_token_expires_at = Parse._encode(this.config.generatePasswordResetTokenExpiresAt());\n    }\n\n    return this.config.database.update('_User', { $or: [{email}, {username: email, email: {$exists: false}}] }, token, {}, true)\n  }\n\n  sendPasswordResetEmail(email) {\n    if (!this.adapter) {\n      throw \"Trying to send a reset password but no adapter is set\";\n      //  TODO: No adapter?\n    }\n\n    return this.setPasswordResetToken(email)\n      .then(user => {\n        const token = encodeURIComponent(user._perishable_token);\n        const username = encodeURIComponent(user.username);\n\n        const link = buildEmailLink(this.config.requestResetPasswordURL, username, token, this.config);\n        const options = {\n          appName: this.config.appName,\n          link: link,\n          user: inflate('_User', user),\n        };\n\n        if (this.adapter.sendPasswordResetEmail) {\n          this.adapter.sendPasswordResetEmail(options);\n        } else {\n          this.adapter.sendMail(this.defaultResetPasswordEmail(options));\n        }\n\n        return Promise.resolve(user);\n      });\n  }\n\n  updatePassword(username, token, password) {\n    return this.checkResetTokenValidity(username, token)\n      .then(user => updateUserPassword(user.objectId, password, this.config))\n      // clear reset password token\n      .then(() => this.config.database.update('_User', {username}, {\n        _perishable_token: {__op: 'Delete'},\n        _perishable_token_expires_at: {__op: 'Delete'}\n      })).catch((error) => {\n        if (error.message) {  // in case of Parse.Error, fail with the error message only\n          return Promise.reject(error.message);\n        } else {\n          return Promise.reject(error);\n        }\n      });\n  }\n\n  defaultVerificationEmail({link, user, appName, }) {\n    const text = \"Hi,\\n\\n\" +\n        \"You are being asked to confirm the e-mail address \" + user.get(\"email\") + \" with \" + appName + \"\\n\\n\" +\n        \"\" +\n        \"Click here to confirm it:\\n\" + link;\n    const to = user.get(\"email\");\n    const subject = 'Please verify your e-mail for ' + appName;\n    return { text, to, subject };\n  }\n\n  defaultResetPasswordEmail({link, user, appName, }) {\n    const text = \"Hi,\\n\\n\" +\n        \"You requested to reset your password for \" + appName +\n        (user.get('username') ? (\" (your username is '\" + user.get('username') + \"')\") : \"\") + \".\\n\\n\" +\n        \"\" +\n        \"Click here to reset it:\\n\" + link;\n    const to = user.get(\"email\") || user.get('username');\n    const subject =  'Password Reset for ' + appName;\n    return { text, to, subject };\n  }\n}\n\n// Mark this private\nfunction updateUserPassword(userId, password, config) {\n  return rest.update(config, Auth.master(config), '_User', { objectId: userId }, {\n    password: password\n  });\n}\n\nfunction buildEmailLink(destination, username, token, config) {\n  const usernameAndToken = `token=${token}&username=${username}`\n\n  if (config.parseFrameURL) {\n    const destinationWithoutHost = destination.replace(config.publicServerURL, '');\n\n    return `${config.parseFrameURL}?link=${encodeURIComponent(destinationWithoutHost)}&${usernameAndToken}`;\n  } else {\n    return `${destination}?${usernameAndToken}`;\n  }\n}\n\nexport default UserController;\n"]} \ No newline at end of file diff --git a/lib/Controllers/index.js b/lib/Controllers/index.js index 2d2a6dfb88..a1996308f7 100644 --- a/lib/Controllers/index.js +++ b/lib/Controllers/index.js @@ -140,7 +140,8 @@ function getFilesController(options) { appId, databaseURI, filesAdapter, - databaseAdapter + databaseAdapter, + preserveFileName } = options; if (!filesAdapter && databaseAdapter) { throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.'; @@ -148,7 +149,7 @@ function getFilesController(options) { const filesControllerAdapter = (0, _AdapterLoader.loadAdapter)(filesAdapter, () => { return new _GridStoreAdapter.GridStoreAdapter(databaseURI); }); - return new _FilesController.FilesController(filesControllerAdapter, appId); + return new _FilesController.FilesController(filesControllerAdapter, appId, { preserveFileName }); } function getUserController(options) { @@ -279,4 +280,5 @@ function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) { mongoOptions: databaseOptions }); } -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/index.js"],"names":["getControllers","getLoggerController","getFilesController","getUserController","getCacheController","getAnalyticsController","getLiveQueryController","getDatabaseController","getHooksController","getPushController","getAuthDataManager","getDatabaseAdapter","options","loggerController","filesController","userController","pushController","hasPushScheduledSupport","hasPushSupport","pushControllerQueue","pushWorker","cacheController","analyticsController","liveQueryController","databaseController","hooksController","authDataManager","appId","jsonLogs","logsFolder","verbose","logLevel","silent","loggerAdapter","loggerOptions","loggerControllerAdapter","WinstonLoggerAdapter","LoggerController","databaseURI","filesAdapter","databaseAdapter","preserveFileName","filesControllerAdapter","GridStoreAdapter","FilesController","emailAdapter","verifyUserEmails","emailControllerAdapter","UserController","cacheAdapter","cacheTTL","cacheMaxSize","cacheControllerAdapter","InMemoryCacheAdapter","ttl","maxSize","CacheController","analyticsAdapter","analyticsControllerAdapter","AnalyticsAdapter","AnalyticsController","LiveQueryController","liveQuery","databaseOptions","collectionPrefix","schemaCacheTTL","enableSingleSchemaCache","defaults","DatabaseController","SchemaCache","webhookKey","HooksController","scheduledPush","push","pushOptions","Object","assign","pushQueueOptions","queueOptions","pushAdapter","adapter","ParsePushAdapter","PushController","disablePushWorker","PushQueue","PushWorker","auth","enableAnonymousUsers","protocol","parsedURI","url","parse","toLowerCase","e","PostgresStorageAdapter","uri","MongoStorageAdapter","mongoOptions"],"mappings":"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","file":"index.js","sourcesContent":["import authDataManager          from '../Adapters/Auth';\nimport { ParseServerOptions }   from '../Options';\nimport { loadAdapter }          from '../Adapters/AdapterLoader';\nimport defaults                 from '../defaults';\nimport url                      from 'url';\n// Controllers\nimport { LoggerController }     from './LoggerController';\nimport { FilesController }      from './FilesController';\nimport { HooksController }      from './HooksController';\nimport { UserController }       from './UserController';\nimport { CacheController }      from './CacheController';\nimport { LiveQueryController }  from './LiveQueryController';\nimport { AnalyticsController }  from './AnalyticsController';\nimport { PushController }       from './PushController';\nimport { PushQueue }            from '../Push/PushQueue';\nimport { PushWorker }           from '../Push/PushWorker';\nimport DatabaseController       from './DatabaseController';\nimport SchemaCache              from './SchemaCache';\n\n// Adapters\nimport { GridStoreAdapter }     from '../Adapters/Files/GridStoreAdapter';\nimport { WinstonLoggerAdapter } from '../Adapters/Logger/WinstonLoggerAdapter';\nimport { InMemoryCacheAdapter } from '../Adapters/Cache/InMemoryCacheAdapter';\nimport { AnalyticsAdapter }     from '../Adapters/Analytics/AnalyticsAdapter';\nimport MongoStorageAdapter      from '../Adapters/Storage/Mongo/MongoStorageAdapter';\nimport PostgresStorageAdapter   from '../Adapters/Storage/Postgres/PostgresStorageAdapter';\nimport ParsePushAdapter         from '@parse/push-adapter';\n\nexport function getControllers(options: ParseServerOptions) {\n  const loggerController = getLoggerController(options);\n  const filesController = getFilesController(options);\n  const userController = getUserController(options);\n  const {\n    pushController,\n    hasPushScheduledSupport,\n    hasPushSupport,\n    pushControllerQueue,\n    pushWorker\n  } = getPushController(options);\n  const cacheController = getCacheController(options);\n  const analyticsController = getAnalyticsController(options);\n  const liveQueryController = getLiveQueryController(options);\n  const databaseController = getDatabaseController(options, cacheController);\n  const hooksController = getHooksController(options, databaseController);\n  const authDataManager = getAuthDataManager(options);\n  return {\n    loggerController,\n    filesController,\n    userController,\n    pushController,\n    hasPushScheduledSupport,\n    hasPushSupport,\n    pushWorker,\n    pushControllerQueue,\n    analyticsController,\n    cacheController,\n    liveQueryController,\n    databaseController,\n    hooksController,\n    authDataManager,\n  };\n}\n\nexport function getLoggerController(options: ParseServerOptions): LoggerController {\n  const {\n    appId,\n    jsonLogs,\n    logsFolder,\n    verbose,\n    logLevel,\n    silent,\n    loggerAdapter,\n  } = options;\n  const loggerOptions = { jsonLogs, logsFolder, verbose, logLevel, silent };\n  const loggerControllerAdapter = loadAdapter(loggerAdapter, WinstonLoggerAdapter, loggerOptions);\n  return new LoggerController(loggerControllerAdapter, appId, loggerOptions);\n}\n\nexport function getFilesController(options: ParseServerOptions): FilesController {\n  const {\n    appId,\n    databaseURI,\n    filesAdapter,\n    databaseAdapter,\n    preserveFileName,\n  } = options;\n  if (!filesAdapter && databaseAdapter) {\n    throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.';\n  }\n  const filesControllerAdapter = loadAdapter(filesAdapter, () => {\n    return new GridStoreAdapter(databaseURI);\n  });\n  return new FilesController(filesControllerAdapter, appId, { preserveFileName });\n}\n\nexport function getUserController(options: ParseServerOptions): UserController {\n  const {\n    appId,\n    emailAdapter,\n    verifyUserEmails,\n  } = options;\n  const emailControllerAdapter = loadAdapter(emailAdapter);\n  return new UserController(emailControllerAdapter, appId, { verifyUserEmails });\n}\n\nexport function getCacheController(options: ParseServerOptions): CacheController {\n  const {\n    appId,\n    cacheAdapter,\n    cacheTTL,\n    cacheMaxSize,\n  } = options;\n  const cacheControllerAdapter = loadAdapter(cacheAdapter, InMemoryCacheAdapter, {appId: appId, ttl: cacheTTL, maxSize: cacheMaxSize });\n  return new CacheController(cacheControllerAdapter, appId);\n}\n\nexport function getAnalyticsController(options: ParseServerOptions): AnalyticsController {\n  const {\n    analyticsAdapter,\n  } = options;\n  const analyticsControllerAdapter = loadAdapter(analyticsAdapter, AnalyticsAdapter);\n  return new AnalyticsController(analyticsControllerAdapter);\n}\n\nexport function getLiveQueryController(options: ParseServerOptions): LiveQueryController {\n  return new LiveQueryController(options.liveQuery);\n}\n\nexport function getDatabaseController(options: ParseServerOptions, cacheController: CacheController): DatabaseController {\n  const {\n    databaseURI,\n    databaseOptions,\n    collectionPrefix,\n    schemaCacheTTL,\n    enableSingleSchemaCache,\n  } = options;\n  let {\n    databaseAdapter\n  } = options;\n  if ((databaseOptions || (databaseURI && databaseURI !== defaults.databaseURI) || collectionPrefix !== defaults.collectionPrefix) && databaseAdapter) {\n    throw 'You cannot specify both a databaseAdapter and a databaseURI/databaseOptions/collectionPrefix.';\n  } else if (!databaseAdapter) {\n    databaseAdapter = getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions)\n  } else {\n    databaseAdapter = loadAdapter(databaseAdapter)\n  }\n  return new DatabaseController(databaseAdapter, new SchemaCache(cacheController, schemaCacheTTL, enableSingleSchemaCache));\n}\n\nexport function getHooksController(options: ParseServerOptions, databaseController: DatabaseController): HooksController {\n  const {\n    appId,\n    webhookKey,\n  } = options;\n  return new HooksController(appId, databaseController, webhookKey);\n}\n\ninterface PushControlling {\n  pushController: PushController,\n  hasPushScheduledSupport: boolean,\n  pushControllerQueue: PushQueue,\n  pushWorker: PushWorker\n}\n\nexport function getPushController(options: ParseServerOptions): PushControlling {\n  const {\n    scheduledPush,\n    push,\n  } = options;\n\n  const pushOptions = Object.assign({}, push);\n  const pushQueueOptions = pushOptions.queueOptions || {};\n  if (pushOptions.queueOptions) {\n    delete pushOptions.queueOptions;\n  }\n\n  // Pass the push options too as it works with the default\n  const pushAdapter = loadAdapter(pushOptions && pushOptions.adapter, ParsePushAdapter, pushOptions);\n  // We pass the options and the base class for the adatper,\n  // Note that passing an instance would work too\n  const pushController = new PushController();\n  const hasPushSupport = !!(pushAdapter && push);\n  const hasPushScheduledSupport = hasPushSupport && (scheduledPush === true);\n\n  const {\n    disablePushWorker\n  } = pushQueueOptions;\n\n  const pushControllerQueue = new PushQueue(pushQueueOptions);\n  let pushWorker;\n  if (!disablePushWorker) {\n    pushWorker = new PushWorker(pushAdapter, pushQueueOptions);\n  }\n  return {\n    pushController,\n    hasPushSupport,\n    hasPushScheduledSupport,\n    pushControllerQueue,\n    pushWorker\n  }\n}\n\nexport function getAuthDataManager(options: ParseServerOptions) {\n  const {\n    auth,\n    enableAnonymousUsers\n  } = options;\n  return authDataManager(auth, enableAnonymousUsers)\n}\n\nexport function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) {\n  let protocol;\n  try {\n    const parsedURI = url.parse(databaseURI);\n    protocol = parsedURI.protocol ? parsedURI.protocol.toLowerCase() : null;\n  } catch(e) { /* */ }\n  switch (protocol) {\n  case 'postgres:':\n    return new PostgresStorageAdapter({\n      uri: databaseURI,\n      collectionPrefix,\n      databaseOptions\n    });\n  default:\n    return new MongoStorageAdapter({\n      uri: databaseURI,\n      collectionPrefix,\n      mongoOptions: databaseOptions,\n    });\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/Controllers/types.js b/lib/Controllers/types.js index 9a390c31f7..49132b6ab4 100644 --- a/lib/Controllers/types.js +++ b/lib/Controllers/types.js @@ -1 +1,2 @@ -"use strict"; \ No newline at end of file +"use strict"; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJ0eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbXX0= \ No newline at end of file diff --git a/lib/LiveQuery/Client.js b/lib/LiveQuery/Client.js index dc97207772..a993f6d96b 100644 --- a/lib/LiveQuery/Client.js +++ b/lib/LiveQuery/Client.js @@ -94,4 +94,5 @@ class Client { } } -exports.Client = Client; \ No newline at end of file +exports.Client = Client; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LiveQuery/Client.js"],"names":["dafaultFields","Client","constructor","id","parseWebSocket","hasMasterKey","roles","subscriptionInfos","Map","pushConnect","_pushEvent","pushSubscribe","pushUnsubscribe","pushCreate","pushEnter","pushUpdate","pushDelete","pushLeave","pushResponse","message","logger","verbose","send","pushError","code","error","reconnect","JSON","stringify","addSubscriptionInfo","requestId","subscriptionInfo","set","getSubscriptionInfo","get","deleteSubscriptionInfo","delete","type","subscriptionId","parseObjectJSON","response","fields","has","_toJSONWithFields","limitedParseObject","field"],"mappings":"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","file":"Client.js","sourcesContent":["import logger from '../logger';\n\nimport type { FlattenedObjectData } from './Subscription';\nexport type Message = { [attr: string]: any };\n\nconst dafaultFields = ['className', 'objectId', 'updatedAt', 'createdAt', 'ACL'];\n\nclass Client {\n  id: number;\n  parseWebSocket: any;\n  hasMasterKey: boolean;\n  userId: string;\n  roles: Array<string>;\n  subscriptionInfos: Object;\n  pushConnect: Function;\n  pushSubscribe: Function;\n  pushUnsubscribe: Function;\n  pushCreate: Function;\n  pushEnter: Function;\n  pushUpdate: Function;\n  pushDelete: Function;\n  pushLeave: Function;\n\n  constructor(id: number, parseWebSocket: any, hasMasterKey: boolean) {\n    this.id = id;\n    this.parseWebSocket = parseWebSocket;\n    this.hasMasterKey = hasMasterKey;\n    this.roles = [];\n    this.subscriptionInfos = new Map();\n    this.pushConnect = this._pushEvent('connected');\n    this.pushSubscribe = this._pushEvent('subscribed');\n    this.pushUnsubscribe = this._pushEvent('unsubscribed');\n    this.pushCreate = this._pushEvent('create');\n    this.pushEnter = this._pushEvent('enter');\n    this.pushUpdate = this._pushEvent('update');\n    this.pushDelete = this._pushEvent('delete');\n    this.pushLeave = this._pushEvent('leave');\n  }\n\n  static pushResponse(parseWebSocket: any, message: Message): void {\n    logger.verbose('Push Response : %j', message);\n    parseWebSocket.send(message);\n  }\n\n  static pushError(parseWebSocket: any, code: number, error: string, reconnect: boolean = true): void {\n    Client.pushResponse(parseWebSocket, JSON.stringify({\n      'op': 'error',\n      'error': error,\n      'code': code,\n      'reconnect': reconnect\n    }));\n  }\n\n  addSubscriptionInfo(requestId: number, subscriptionInfo: any): void {\n    this.subscriptionInfos.set(requestId, subscriptionInfo);\n  }\n\n  getSubscriptionInfo(requestId: number): any {\n    return this.subscriptionInfos.get(requestId);\n  }\n\n  deleteSubscriptionInfo(requestId: number): void {\n    return this.subscriptionInfos.delete(requestId);\n  }\n\n  _pushEvent(type: string): Function {\n    return function(subscriptionId: number, parseObjectJSON: any): void {\n      const response: Message = {\n        'op' : type,\n        'clientId' : this.id\n      };\n      if (typeof subscriptionId !== 'undefined') {\n        response['requestId'] = subscriptionId;\n      }\n      if (typeof parseObjectJSON !== 'undefined') {\n        let fields;\n        if (this.subscriptionInfos.has(subscriptionId)) {\n          fields = this.subscriptionInfos.get(subscriptionId).fields;\n        }\n        response['object'] = this._toJSONWithFields(parseObjectJSON, fields);\n      }\n      Client.pushResponse(this.parseWebSocket, JSON.stringify(response));\n    }\n  }\n\n  _toJSONWithFields(parseObjectJSON: any, fields: any): FlattenedObjectData {\n    if (!fields) {\n      return parseObjectJSON;\n    }\n    const limitedParseObject = {};\n    for (const field of dafaultFields) {\n      limitedParseObject[field] = parseObjectJSON[field];\n    }\n    for (const field of fields) {\n      if (field in parseObjectJSON) {\n        limitedParseObject[field] = parseObjectJSON[field];\n      }\n    }\n    return limitedParseObject;\n  }\n}\n\nexport {\n  Client\n}\n"]} \ No newline at end of file diff --git a/lib/LiveQuery/Id.js b/lib/LiveQuery/Id.js index 72fb66d6a6..70e7eaed52 100644 --- a/lib/LiveQuery/Id.js +++ b/lib/LiveQuery/Id.js @@ -19,4 +19,5 @@ class Id { } } -module.exports = Id; \ No newline at end of file +module.exports = Id; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9MaXZlUXVlcnkvSWQuanMiXSwibmFtZXMiOlsiSWQiLCJjb25zdHJ1Y3RvciIsImNsYXNzTmFtZSIsIm9iamVjdElkIiwidG9TdHJpbmciLCJmcm9tU3RyaW5nIiwic3RyIiwic3BsaXQiLCJsZW5ndGgiLCJUeXBlRXJyb3IiLCJtb2R1bGUiLCJleHBvcnRzIl0sIm1hcHBpbmdzIjoiOztBQUFBLE1BQU1BLEVBQU4sQ0FBUzs7QUFJUEMsY0FBWUMsU0FBWixFQUErQkMsUUFBL0IsRUFBaUQ7QUFDL0MsU0FBS0QsU0FBTCxHQUFpQkEsU0FBakI7QUFDQSxTQUFLQyxRQUFMLEdBQWdCQSxRQUFoQjtBQUNEO0FBQ0RDLGFBQW1CO0FBQ2pCLFdBQU8sS0FBS0YsU0FBTCxHQUFpQixHQUFqQixHQUF1QixLQUFLQyxRQUFuQztBQUNEOztBQUVELFNBQU9FLFVBQVAsQ0FBa0JDLEdBQWxCLEVBQStCO0FBQzdCLFFBQUlDLFFBQVFELElBQUlDLEtBQUosQ0FBVSxHQUFWLENBQVo7QUFDQSxRQUFJQSxNQUFNQyxNQUFOLEtBQWlCLENBQXJCLEVBQXdCO0FBQ3RCLFlBQU0sSUFBSUMsU0FBSixDQUFjLDBDQUFkLENBQU47QUFDRDtBQUNELFdBQU8sSUFBSVQsRUFBSixDQUFPTyxNQUFNLENBQU4sQ0FBUCxFQUFpQkEsTUFBTSxDQUFOLENBQWpCLENBQVA7QUFDRDtBQWxCTTs7QUFxQlRHLE9BQU9DLE9BQVAsR0FBaUJYLEVBQWpCIiwiZmlsZSI6IklkLmpzIiwic291cmNlc0NvbnRlbnQiOlsiY2xhc3MgSWQge1xuICBjbGFzc05hbWU6IHN0cmluZztcbiAgb2JqZWN0SWQ6IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihjbGFzc05hbWU6IHN0cmluZywgb2JqZWN0SWQ6IHN0cmluZykge1xuICAgIHRoaXMuY2xhc3NOYW1lID0gY2xhc3NOYW1lO1xuICAgIHRoaXMub2JqZWN0SWQgPSBvYmplY3RJZDtcbiAgfVxuICB0b1N0cmluZygpOiBzdHJpbmcge1xuICAgIHJldHVybiB0aGlzLmNsYXNzTmFtZSArICc6JyArIHRoaXMub2JqZWN0SWQ7XG4gIH1cblxuICBzdGF0aWMgZnJvbVN0cmluZyhzdHI6IHN0cmluZykge1xuICAgIHZhciBzcGxpdCA9IHN0ci5zcGxpdCgnOicpO1xuICAgIGlmIChzcGxpdC5sZW5ndGggIT09IDIpIHtcbiAgICAgIHRocm93IG5ldyBUeXBlRXJyb3IoJ0Nhbm5vdCBjcmVhdGUgSWQgb2JqZWN0IGZyb20gdGhpcyBzdHJpbmcnKTtcbiAgICB9XG4gICAgcmV0dXJuIG5ldyBJZChzcGxpdFswXSwgc3BsaXRbMV0pO1xuICB9XG59XG5cbm1vZHVsZS5leHBvcnRzID0gSWQ7XG4iXX0= \ No newline at end of file diff --git a/lib/LiveQuery/ParseCloudCodePublisher.js b/lib/LiveQuery/ParseCloudCodePublisher.js index cbc1c691bf..7c744c65e8 100644 --- a/lib/LiveQuery/ParseCloudCodePublisher.js +++ b/lib/LiveQuery/ParseCloudCodePublisher.js @@ -47,4 +47,5 @@ class ParseCloudCodePublisher { } } -exports.ParseCloudCodePublisher = ParseCloudCodePublisher; \ No newline at end of file +exports.ParseCloudCodePublisher = ParseCloudCodePublisher; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/LiveQuery/ParseLiveQueryServer.js b/lib/LiveQuery/ParseLiveQueryServer.js index 30188195ee..541a7490c9 100644 --- a/lib/LiveQuery/ParseLiveQueryServer.js +++ b/lib/LiveQuery/ParseLiveQueryServer.js @@ -577,4 +577,5 @@ class ParseLiveQueryServer { } } -exports.ParseLiveQueryServer = ParseLiveQueryServer; \ No newline at end of file +exports.ParseLiveQueryServer = ParseLiveQueryServer; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LiveQuery/ParseLiveQueryServer.js"],"names":["ParseLiveQueryServer","constructor","server","config","clients","Map","subscriptions","keyPairs","key","Object","keys","set","logger","verbose","Parse","disableSingleInstance","serverURL","appId","applicationId","javascriptKey","javaScriptKey","masterKey","initialize","parseWebSocketServer","ParseWebSocketServer","parseWebsocket","_onConnect","websocketTimeout","subscriber","ParsePubSub","createSubscriber","subscribe","on","channel","messageStr","message","JSON","parse","e","error","_inflateParseObject","_onAfterSave","_onAfterDelete","sessionTokenCache","SessionTokenCache","cacheTimeout","currentParseObject","className","parseObject","_finishFetch","originalParseObject","deletedParseObject","toJSON","id","size","classSubscriptions","get","debug","subscription","values","isSubscriptionMatched","_matchesSubscription","clientId","requestIds","_","entries","clientRequestIds","client","requestId","acl","getACL","_matchesACL","then","isMatched","pushDelete","isOriginalSubscriptionMatched","isCurrentSubscriptionMatched","originalACLCheckingPromise","Promise","as","originalACL","currentACLCheckingPromise","currentACL","when","isOriginalMatched","isCurrentMatched","hash","type","functionName","request","tv4","validate","RequestSchema","op","Client","pushError","_handleConnect","_handleSubscribe","_handleUpdateSubscription","_handleUnsubscribe","info","has","event","delete","subscriptionInfo","subscriptionInfos","deleteClientSubscription","hasSubscribingClient","query","getPublicReadAccess","hasMasterKey","getSubscriptionInfo","subscriptionSessionToken","sessionToken","getUserId","userId","getReadAccess","isSubscriptionSessionTokenMatched","resolve","reject","acl_has_roles","permissionsById","some","startsWith","user","User","rolesQuery","Query","Role","equalTo","find","useMasterKey","roles","role","getRoleReadAccess","catch","isRoleMatched","clientSessionToken","_validateKeys","_hasMasterKey","pushConnect","validKeyPairs","hasOwnProperty","isValid","secret","subscriptionHash","Subscription","where","fields","addSubscriptionInfo","addClientSubscription","pushSubscribe","notifyClient","deleteSubscriptionInfo","pushUnsubscribe"],"mappings":";;;;;;;AAAA;;;;AACA;;;;AACA;;AACA;;AACA;;AACA;;;;AACA;;;;AACA;;AACA;;AACA;;AACA;;;;AACA;;;;AACA;;;;AAEA,MAAMA,oBAAN,CAA2B;AAEzB;AAOAC,cAAYC,MAAZ,EAAyBC,MAAzB,EAAsC;AACpC,SAAKD,MAAL,GAAcA,MAAd;AACA,SAAKE,OAAL,GAAe,IAAIC,GAAJ,EAAf;AACA,SAAKC,aAAL,GAAqB,IAAID,GAAJ,EAArB;;AAEAF,aAASA,UAAU,EAAnB;;AAEA;AACA,UAAMI,WAAWJ,OAAOI,QAAP,IAAmB,EAApC;AACA,SAAKA,QAAL,GAAgB,IAAIF,GAAJ,EAAhB;AACA,SAAK,MAAMG,GAAX,IAAkBC,OAAOC,IAAP,CAAYH,QAAZ,CAAlB,EAAyC;AACvC,WAAKA,QAAL,CAAcI,GAAd,CAAkBH,GAAlB,EAAuBD,SAASC,GAAT,CAAvB;AACD;AACDI,qBAAOC,OAAP,CAAe,mBAAf,EAAoC,KAAKN,QAAzC;;AAEA;AACAO,mBAAML,MAAN,CAAaM,qBAAb;;AAEA,UAAMC,YAAYb,OAAOa,SAAP,IAAoBF,eAAME,SAA5C;AACAF,mBAAME,SAAN,GAAkBA,SAAlB;AACA,UAAMC,QAAQd,OAAOc,KAAP,IAAgBH,eAAMI,aAApC;AACA,UAAMC,gBAAgBL,eAAMM,aAA5B;AACA,UAAMC,YAAYlB,OAAOkB,SAAP,IAAoBP,eAAMO,SAA5C;AACAP,mBAAMQ,UAAN,CAAiBL,KAAjB,EAAwBE,aAAxB,EAAuCE,SAAvC;;AAEA;AACA,SAAKE,oBAAL,GAA4B,IAAIC,0CAAJ,CAC1BtB,MAD0B,EAEzBuB,cAAD,IAAoB,KAAKC,UAAL,CAAgBD,cAAhB,CAFM,EAG1BtB,OAAOwB,gBAHmB,CAA5B;;AAMA;AACA,SAAKC,UAAL,GAAkBC,yBAAYC,gBAAZ,CAA6B3B,MAA7B,CAAlB;AACA,SAAKyB,UAAL,CAAgBG,SAAhB,CAA0BjB,eAAMI,aAAN,GAAsB,WAAhD;AACA,SAAKU,UAAL,CAAgBG,SAAhB,CAA0BjB,eAAMI,aAAN,GAAsB,aAAhD;AACA;AACA;AACA,SAAKU,UAAL,CAAgBI,EAAhB,CAAmB,SAAnB,EAA8B,CAACC,OAAD,EAAUC,UAAV,KAAyB;AACrDtB,uBAAOC,OAAP,CAAe,uBAAf,EAAwCqB,UAAxC;AACA,UAAIC,OAAJ;AACA,UAAI;AACFA,kBAAUC,KAAKC,KAAL,CAAWH,UAAX,CAAV;AACD,OAFD,CAEE,OAAMI,CAAN,EAAS;AACT1B,yBAAO2B,KAAP,CAAa,yBAAb,EAAwCL,UAAxC,EAAoDI,CAApD;AACA;AACD;AACD,WAAKE,mBAAL,CAAyBL,OAAzB;AACA,UAAIF,YAAYnB,eAAMI,aAAN,GAAsB,WAAtC,EAAmD;AACjD,aAAKuB,YAAL,CAAkBN,OAAlB;AACD,OAFD,MAEO,IAAIF,YAAYnB,eAAMI,aAAN,GAAsB,aAAtC,EAAqD;AAC1D,aAAKwB,cAAL,CAAoBP,OAApB;AACD,OAFM,MAEA;AACLvB,yBAAO2B,KAAP,CAAa,wCAAb,EAAuDJ,OAAvD,EAAgEF,OAAhE;AACD;AACF,KAjBD;;AAmBA;AACA,SAAKU,iBAAL,GAAyB,IAAIC,oCAAJ,CAAsBzC,OAAO0C,YAA7B,CAAzB;AACD;;AAED;AACA;;AAjEA;AAkEAL,sBAAoBL,OAApB,EAAwC;AACtC;AACA,UAAMW,qBAAqBX,QAAQW,kBAAnC;AACA,QAAIC,YAAYD,mBAAmBC,SAAnC;AACA,QAAIC,cAAc,IAAIlC,eAAML,MAAV,CAAiBsC,SAAjB,CAAlB;AACAC,gBAAYC,YAAZ,CAAyBH,kBAAzB;AACAX,YAAQW,kBAAR,GAA6BE,WAA7B;AACA;AACA,UAAME,sBAAsBf,QAAQe,mBAApC;AACA,QAAIA,mBAAJ,EAAyB;AACvBH,kBAAYG,oBAAoBH,SAAhC;AACAC,oBAAc,IAAIlC,eAAML,MAAV,CAAiBsC,SAAjB,CAAd;AACAC,kBAAYC,YAAZ,CAAyBC,mBAAzB;AACAf,cAAQe,mBAAR,GAA8BF,WAA9B;AACD;AACF;;AAED;AACA;AACAN,iBAAeP,OAAf,EAAmC;AACjCvB,qBAAOC,OAAP,CAAeC,eAAMI,aAAN,GAAsB,0BAArC;;AAEA,UAAMiC,qBAAqBhB,QAAQW,kBAAR,CAA2BM,MAA3B,EAA3B;AACA,UAAML,YAAYI,mBAAmBJ,SAArC;AACAnC,qBAAOC,OAAP,CAAe,8BAAf,EAA+CkC,SAA/C,EAA0DI,mBAAmBE,EAA7E;AACAzC,qBAAOC,OAAP,CAAe,4BAAf,EAA6C,KAAKT,OAAL,CAAakD,IAA1D;;AAEA,UAAMC,qBAAqB,KAAKjD,aAAL,CAAmBkD,GAAnB,CAAuBT,SAAvB,CAA3B;AACA,QAAI,OAAOQ,kBAAP,KAA8B,WAAlC,EAA+C;AAC7C3C,uBAAO6C,KAAP,CAAa,iDAAiDV,SAA9D;AACA;AACD;AACD,SAAK,MAAMW,YAAX,IAA2BH,mBAAmBI,MAAnB,EAA3B,EAAwD;AACtD,YAAMC,wBAAwB,KAAKC,oBAAL,CAA0BV,kBAA1B,EAA8CO,YAA9C,CAA9B;AACA,UAAI,CAACE,qBAAL,EAA4B;AAC1B;AACD;AACD,WAAK,MAAM,CAACE,QAAD,EAAWC,UAAX,CAAX,IAAqCC,iBAAEC,OAAF,CAAUP,aAAaQ,gBAAvB,CAArC,EAA+E;AAC7E,cAAMC,SAAS,KAAK/D,OAAL,CAAaoD,GAAb,CAAiBM,QAAjB,CAAf;AACA,YAAI,OAAOK,MAAP,KAAkB,WAAtB,EAAmC;AACjC;AACD;AACD,aAAK,MAAMC,SAAX,IAAwBL,UAAxB,EAAoC;AAClC,gBAAMM,MAAMlC,QAAQW,kBAAR,CAA2BwB,MAA3B,EAAZ;AACA;AACA,eAAKC,WAAL,CAAiBF,GAAjB,EAAsBF,MAAtB,EAA8BC,SAA9B,EAAyCI,IAAzC,CAA+CC,SAAD,IAAe;AAC3D,gBAAI,CAACA,SAAL,EAAgB;AACd,qBAAO,IAAP;AACD;AACDN,mBAAOO,UAAP,CAAkBN,SAAlB,EAA6BjB,kBAA7B;AACD,WALD,EAKIZ,KAAD,IAAW;AACZ3B,6BAAO2B,KAAP,CAAa,uBAAb,EAAsCA,KAAtC;AACD,WAPD;AAQD;AACF;AACF;AACF;;AAED;AACA;AACAE,eAAaN,OAAb,EAAiC;AAC/BvB,qBAAOC,OAAP,CAAeC,eAAMI,aAAN,GAAsB,wBAArC;;AAEA,QAAIgC,sBAAsB,IAA1B;AACA,QAAIf,QAAQe,mBAAZ,EAAiC;AAC/BA,4BAAsBf,QAAQe,mBAAR,CAA4BE,MAA5B,EAAtB;AACD;AACD,UAAMN,qBAAqBX,QAAQW,kBAAR,CAA2BM,MAA3B,EAA3B;AACA,UAAML,YAAYD,mBAAmBC,SAArC;AACAnC,qBAAOC,OAAP,CAAe,8BAAf,EAA+CkC,SAA/C,EAA0DD,mBAAmBO,EAA7E;AACAzC,qBAAOC,OAAP,CAAe,4BAAf,EAA6C,KAAKT,OAAL,CAAakD,IAA1D;;AAEA,UAAMC,qBAAqB,KAAKjD,aAAL,CAAmBkD,GAAnB,CAAuBT,SAAvB,CAA3B;AACA,QAAI,OAAOQ,kBAAP,KAA8B,WAAlC,EAA+C;AAC7C3C,uBAAO6C,KAAP,CAAa,iDAAiDV,SAA9D;AACA;AACD;AACD,SAAK,MAAMW,YAAX,IAA2BH,mBAAmBI,MAAnB,EAA3B,EAAwD;AACtD,YAAMgB,gCAAgC,KAAKd,oBAAL,CAA0BX,mBAA1B,EAA+CQ,YAA/C,CAAtC;AACA,YAAMkB,+BAA+B,KAAKf,oBAAL,CAA0Bf,kBAA1B,EAA8CY,YAA9C,CAArC;AACA,WAAK,MAAM,CAACI,QAAD,EAAWC,UAAX,CAAX,IAAqCC,iBAAEC,OAAF,CAAUP,aAAaQ,gBAAvB,CAArC,EAA+E;AAC7E,cAAMC,SAAS,KAAK/D,OAAL,CAAaoD,GAAb,CAAiBM,QAAjB,CAAf;AACA,YAAI,OAAOK,MAAP,KAAkB,WAAtB,EAAmC;AACjC;AACD;AACD,aAAK,MAAMC,SAAX,IAAwBL,UAAxB,EAAoC;AAClC;AACA;AACA,cAAIc,0BAAJ;AACA,cAAI,CAACF,6BAAL,EAAoC;AAClCE,yCAA6B/D,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,KAAjB,CAA7B;AACD,WAFD,MAEO;AACL,gBAAIC,WAAJ;AACA,gBAAI7C,QAAQe,mBAAZ,EAAiC;AAC/B8B,4BAAc7C,QAAQe,mBAAR,CAA4BoB,MAA5B,EAAd;AACD;AACDO,yCAA6B,KAAKN,WAAL,CAAiBS,WAAjB,EAA8Bb,MAA9B,EAAsCC,SAAtC,CAA7B;AACD;AACD;AACA;AACA,cAAIa,yBAAJ;AACA,cAAI,CAACL,4BAAL,EAAmC;AACjCK,wCAA4BnE,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,KAAjB,CAA5B;AACD,WAFD,MAEO;AACL,kBAAMG,aAAa/C,QAAQW,kBAAR,CAA2BwB,MAA3B,EAAnB;AACAW,wCAA4B,KAAKV,WAAL,CAAiBW,UAAjB,EAA6Bf,MAA7B,EAAqCC,SAArC,CAA5B;AACD;;AAEDtD,yBAAMgE,OAAN,CAAcK,IAAd,CACEN,0BADF,EAEEI,yBAFF,EAGET,IAHF,CAGO,CAACY,iBAAD,EAAoBC,gBAApB,KAAyC;AAC9CzE,6BAAOC,OAAP,CAAe,8DAAf,EACEqC,mBADF,EAEEJ,kBAFF,EAGE6B,6BAHF,EAIEC,4BAJF,EAKEQ,iBALF,EAMEC,gBANF,EAOE3B,aAAa4B,IAPf;;AAUA;AACA,gBAAIC,IAAJ;AACA,gBAAIH,qBAAqBC,gBAAzB,EAA2C;AACzCE,qBAAO,QAAP;AACD,aAFD,MAEO,IAAIH,qBAAqB,CAACC,gBAA1B,EAA4C;AACjDE,qBAAO,OAAP;AACD,aAFM,MAEA,IAAI,CAACH,iBAAD,IAAsBC,gBAA1B,EAA4C;AACjD,kBAAInC,mBAAJ,EAAyB;AACvBqC,uBAAO,OAAP;AACD,eAFD,MAEO;AACLA,uBAAO,QAAP;AACD;AACF,aANM,MAMA;AACL,qBAAO,IAAP;AACD;AACD,kBAAMC,eAAe,SAASD,IAA9B;AACApB,mBAAOqB,YAAP,EAAqBpB,SAArB,EAAgCtB,kBAAhC;AACD,WA/BD,EA+BIP,KAAD,IAAW;AACZ3B,6BAAO2B,KAAP,CAAa,uBAAb,EAAsCA,KAAtC;AACD,WAjCD;AAkCD;AACF;AACF;AACF;;AAEDb,aAAWD,cAAX,EAAsC;AACpCA,mBAAeO,EAAf,CAAkB,SAAlB,EAA8ByD,OAAD,IAAa;AACxC,UAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;AAC/B,YAAI;AACFA,oBAAUrD,KAAKC,KAAL,CAAWoD,OAAX,CAAV;AACD,SAFD,CAEE,OAAMnD,CAAN,EAAS;AACT1B,2BAAO2B,KAAP,CAAa,yBAAb,EAAwCkD,OAAxC,EAAiDnD,CAAjD;AACA;AACD;AACF;AACD1B,uBAAOC,OAAP,CAAe,aAAf,EAA8B4E,OAA9B;;AAEA;AACA,UAAI,CAACC,aAAIC,QAAJ,CAAaF,OAAb,EAAsBG,wBAAc,SAAd,CAAtB,CAAD,IAAoD,CAACF,aAAIC,QAAJ,CAAaF,OAAb,EAAsBG,wBAAcH,QAAQI,EAAtB,CAAtB,CAAzD,EAA2G;AACzGC,uBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoCiE,aAAInD,KAAJ,CAAUJ,OAA9C;AACAvB,yBAAO2B,KAAP,CAAa,0BAAb,EAAyCmD,aAAInD,KAAJ,CAAUJ,OAAnD;AACA;AACD;;AAED,cAAOsD,QAAQI,EAAf;AACA,aAAK,SAAL;AACE,eAAKG,cAAL,CAAoBvE,cAApB,EAAoCgE,OAApC;AACA;AACF,aAAK,WAAL;AACE,eAAKQ,gBAAL,CAAsBxE,cAAtB,EAAsCgE,OAAtC;AACA;AACF,aAAK,QAAL;AACE,eAAKS,yBAAL,CAA+BzE,cAA/B,EAA+CgE,OAA/C;AACA;AACF,aAAK,aAAL;AACE,eAAKU,kBAAL,CAAwB1E,cAAxB,EAAwCgE,OAAxC;AACA;AACF;AACEK,yBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoC,uBAApC;AACAb,2BAAO2B,KAAP,CAAa,uBAAb,EAAsCkD,QAAQI,EAA9C;AAfF;AAiBD,KAnCD;;AAqCApE,mBAAeO,EAAf,CAAkB,YAAlB,EAAgC,MAAM;AACpCpB,uBAAOwF,IAAP,CAAa,sBAAqB3E,eAAeqC,QAAS,EAA1D;AACA,YAAMA,WAAWrC,eAAeqC,QAAhC;AACA,UAAI,CAAC,KAAK1D,OAAL,CAAaiG,GAAb,CAAiBvC,QAAjB,CAAL,EAAiC;AAC/B,iDAA0B;AACxBwC,iBAAO,qBADiB;AAExBlG,mBAAS,KAAKA,OAAL,CAAakD,IAFE;AAGxBhD,yBAAe,KAAKA,aAAL,CAAmBgD,IAHV;AAIxBf,iBAAQ,yBAAwBuB,QAAS;AAJjB,SAA1B;AAMAlD,yBAAO2B,KAAP,CAAc,uBAAsBuB,QAAS,gBAA7C;AACA;AACD;;AAED;AACA,YAAMK,SAAS,KAAK/D,OAAL,CAAaoD,GAAb,CAAiBM,QAAjB,CAAf;AACA,WAAK1D,OAAL,CAAamG,MAAb,CAAoBzC,QAApB;;AAEA;AACA,WAAK,MAAM,CAACM,SAAD,EAAYoC,gBAAZ,CAAX,IAA4CxC,iBAAEC,OAAF,CAAUE,OAAOsC,iBAAjB,CAA5C,EAAiF;AAC/E,cAAM/C,eAAe8C,iBAAiB9C,YAAtC;AACAA,qBAAagD,wBAAb,CAAsC5C,QAAtC,EAAgDM,SAAhD;;AAEA;AACA,cAAMb,qBAAqB,KAAKjD,aAAL,CAAmBkD,GAAnB,CAAuBE,aAAaX,SAApC,CAA3B;AACA,YAAI,CAACW,aAAaiD,oBAAb,EAAL,EAA0C;AACxCpD,6BAAmBgD,MAAnB,CAA0B7C,aAAa4B,IAAvC;AACD;AACD;AACA,YAAI/B,mBAAmBD,IAAnB,KAA4B,CAAhC,EAAmC;AACjC,eAAKhD,aAAL,CAAmBiG,MAAnB,CAA0B7C,aAAaX,SAAvC;AACD;AACF;;AAEDnC,uBAAOC,OAAP,CAAe,oBAAf,EAAqC,KAAKT,OAAL,CAAakD,IAAlD;AACA1C,uBAAOC,OAAP,CAAe,0BAAf,EAA2C,KAAKP,aAAL,CAAmBgD,IAA9D;AACA,+CAA0B;AACxBgD,eAAO,eADiB;AAExBlG,iBAAS,KAAKA,OAAL,CAAakD,IAFE;AAGxBhD,uBAAe,KAAKA,aAAL,CAAmBgD;AAHV,OAA1B;AAKD,KAzCD;;AA2CA,6CAA0B;AACxBgD,aAAO,YADiB;AAExBlG,eAAS,KAAKA,OAAL,CAAakD,IAFE;AAGxBhD,qBAAe,KAAKA,aAAL,CAAmBgD;AAHV,KAA1B;AAKD;;AAEDO,uBAAqBb,WAArB,EAAuCU,YAAvC,EAAmE;AACjE;AACA,QAAI,CAACV,WAAL,EAAkB;AAChB,aAAO,KAAP;AACD;AACD,WAAO,8BAAaA,WAAb,EAA0BU,aAAakD,KAAvC,CAAP;AACD;;AAEDrC,cAAYF,GAAZ,EAAsBF,MAAtB,EAAmCC,SAAnC,EAA2D;AACzD;AACA,QAAI,CAACC,GAAD,IAAQA,IAAIwC,mBAAJ,EAAR,IAAqC1C,OAAO2C,YAAhD,EAA8D;AAC5D,aAAOhG,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,IAAjB,CAAP;AACD;AACD;AACA,UAAMyB,mBAAmBrC,OAAO4C,mBAAP,CAA2B3C,SAA3B,CAAzB;AACA,QAAI,OAAOoC,gBAAP,KAA4B,WAAhC,EAA6C;AAC3C,aAAO1F,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,KAAjB,CAAP;AACD;;AAED,UAAMiC,2BAA2BR,iBAAiBS,YAAlD;AACA,WAAO,KAAKtE,iBAAL,CAAuBuE,SAAvB,CAAiCF,wBAAjC,EAA2DxC,IAA3D,CAAiE2C,MAAD,IAAY;AACjF,aAAO9C,IAAI+C,aAAJ,CAAkBD,MAAlB,CAAP;AACD,KAFM,EAEJ3C,IAFI,CAEE6C,iCAAD,IAAuC;AAC7C,UAAIA,iCAAJ,EAAuC;AACrC,eAAOvG,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,IAAjB,CAAP;AACD;;AAED;AACA,aAAO,IAAIjE,eAAMgE,OAAV,CAAkB,CAACwC,OAAD,EAAUC,MAAV,KAAqB;;AAE5C;AACA,cAAMC,gBAAgB/G,OAAOC,IAAP,CAAY2D,IAAIoD,eAAhB,EAAiCC,IAAjC,CAAsClH,OAAOA,IAAImH,UAAJ,CAAe,OAAf,CAA7C,CAAtB;AACA,YAAI,CAACH,aAAL,EAAoB;AAClB,iBAAOF,QAAQ,KAAR,CAAP;AACD;;AAED,aAAK3E,iBAAL,CAAuBuE,SAAvB,CAAiCF,wBAAjC,EACGxC,IADH,CACS2C,MAAD,IAAY;;AAEhB;AACA,cAAI,CAACA,MAAL,EAAa;AACX,mBAAOrG,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,IAAjB,CAAP;AACD;;AAED;AACA;AACA,cAAI6C,OAAO,IAAI9G,eAAM+G,IAAV,EAAX;AACAD,eAAKvE,EAAL,GAAU8D,MAAV;AACA,iBAAOS,IAAP;AAED,SAdH,EAeGpD,IAfH,CAeSoD,IAAD,IAAU;;AAEd;AACA,cAAI,CAACA,IAAL,EAAW;AACT,mBAAO9G,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,EAAjB,CAAP;AACD;;AAED;AACA,cAAI+C,aAAa,IAAIhH,eAAMiH,KAAV,CAAgBjH,eAAMkH,IAAtB,CAAjB;AACAF,qBAAWG,OAAX,CAAmB,OAAnB,EAA4BL,IAA5B;AACA,iBAAOE,WAAWI,IAAX,CAAgB,EAACC,cAAa,IAAd,EAAhB,CAAP;AACD,SA1BH,EA2BE3D,IA3BF,CA2BQ4D,KAAD,IAAW;;AAEd;AACA,eAAK,MAAMC,IAAX,IAAmBD,KAAnB,EAA0B;AACxB,gBAAI/D,IAAIiE,iBAAJ,CAAsBD,IAAtB,CAAJ,EAAiC;AAC/B,qBAAOf,QAAQ,IAAR,CAAP;AACD;AACF;AACDA,kBAAQ,KAAR;AACD,SApCH,EAqCGiB,KArCH,CAqCUhG,KAAD,IAAW;AAChBgF,iBAAOhF,KAAP;AACD,SAvCH;AAyCD,OAjDM,CAAP;AAkDD,KA1DM,EA0DJiC,IA1DI,CA0DEgE,aAAD,IAAmB;;AAEzB,UAAGA,aAAH,EAAkB;AAChB,eAAO1H,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,IAAjB,CAAP;AACD;;AAED;AACA,YAAM0D,qBAAqBtE,OAAO8C,YAAlC;AACA,aAAO,KAAKtE,iBAAL,CAAuBuE,SAAvB,CAAiCuB,kBAAjC,EAAqDjE,IAArD,CAA2D2C,MAAD,IAAY;AAC3E,eAAO9C,IAAI+C,aAAJ,CAAkBD,MAAlB,CAAP;AACD,OAFM,CAAP;AAGD,KArEM,EAqEJ3C,IArEI,CAqEEC,SAAD,IAAe;AACrB,aAAO3D,eAAMgE,OAAN,CAAcC,EAAd,CAAiBN,SAAjB,CAAP;AACD,KAvEM,EAuEJ,MAAM;AACP,aAAO3D,eAAMgE,OAAN,CAAcC,EAAd,CAAiB,KAAjB,CAAP;AACD,KAzEM,CAAP;AA0ED;;AAEDiB,iBAAevE,cAAf,EAAoCgE,OAApC,EAAuD;AACrD,QAAI,CAAC,KAAKiD,aAAL,CAAmBjD,OAAnB,EAA4B,KAAKlF,QAAjC,CAAL,EAAiD;AAC/CuF,qBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoC,6BAApC;AACAb,uBAAO2B,KAAP,CAAa,6BAAb;AACA;AACD;AACD,UAAMuE,eAAe,KAAK6B,aAAL,CAAmBlD,OAAnB,EAA4B,KAAKlF,QAAjC,CAArB;AACA,UAAMuD,WAAW,qBAAjB;AACA,UAAMK,SAAS,IAAI2B,cAAJ,CAAWhC,QAAX,EAAqBrC,cAArB,EAAqCqF,YAArC,CAAf;AACArF,mBAAeqC,QAAf,GAA0BA,QAA1B;AACA,SAAK1D,OAAL,CAAaO,GAAb,CAAiBc,eAAeqC,QAAhC,EAA0CK,MAA1C;AACAvD,qBAAOwF,IAAP,CAAa,sBAAqB3E,eAAeqC,QAAS,EAA1D;AACAK,WAAOyE,WAAP;AACA,6CAA0B;AACxBtC,aAAO,SADiB;AAExBlG,eAAS,KAAKA,OAAL,CAAakD,IAFE;AAGxBhD,qBAAe,KAAKA,aAAL,CAAmBgD;AAHV,KAA1B;AAKD;;AAEDqF,gBAAclD,OAAd,EAA4BoD,aAA5B,EAAyD;AACvD,QAAG,CAACA,aAAD,IAAkBA,cAAcvF,IAAd,IAAsB,CAAxC,IACD,CAACuF,cAAcxC,GAAd,CAAkB,WAAlB,CADH,EACmC;AACjC,aAAO,KAAP;AACD;AACD,QAAG,CAACZ,OAAD,IAAY,CAACA,QAAQqD,cAAR,CAAuB,WAAvB,CAAhB,EAAqD;AACnD,aAAO,KAAP;AACD;AACD,WAAOrD,QAAQpE,SAAR,KAAsBwH,cAAcrF,GAAd,CAAkB,WAAlB,CAA7B;AACD;;AAEDkF,gBAAcjD,OAAd,EAA4BoD,aAA5B,EAAyD;AACvD,QAAI,CAACA,aAAD,IAAkBA,cAAcvF,IAAd,IAAsB,CAA5C,EAA+C;AAC7C,aAAO,IAAP;AACD;AACD,QAAIyF,UAAU,KAAd;AACA,SAAK,MAAM,CAACvI,GAAD,EAAMwI,MAAN,CAAX,IAA4BH,aAA5B,EAA2C;AACzC,UAAI,CAACpD,QAAQjF,GAAR,CAAD,IAAiBiF,QAAQjF,GAAR,MAAiBwI,MAAtC,EAA8C;AAC5C;AACD;AACDD,gBAAU,IAAV;AACA;AACD;AACD,WAAOA,OAAP;AACD;;AAED9C,mBAAiBxE,cAAjB,EAAsCgE,OAAtC,EAAyD;AACvD;AACA,QAAI,CAAChE,eAAeqH,cAAf,CAA8B,UAA9B,CAAL,EAAgD;AAC9ChD,qBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoC,8EAApC;AACAb,uBAAO2B,KAAP,CAAa,8EAAb;AACA;AACD;AACD,UAAM4B,SAAS,KAAK/D,OAAL,CAAaoD,GAAb,CAAiB/B,eAAeqC,QAAhC,CAAf;;AAEA;AACA,UAAMmF,mBAAmB,2BAAUxD,QAAQmB,KAAlB,CAAzB;AACA;AACA,UAAM7D,YAAY0C,QAAQmB,KAAR,CAAc7D,SAAhC;AACA,QAAI,CAAC,KAAKzC,aAAL,CAAmB+F,GAAnB,CAAuBtD,SAAvB,CAAL,EAAwC;AACtC,WAAKzC,aAAL,CAAmBK,GAAnB,CAAuBoC,SAAvB,EAAkC,IAAI1C,GAAJ,EAAlC;AACD;AACD,UAAMkD,qBAAqB,KAAKjD,aAAL,CAAmBkD,GAAnB,CAAuBT,SAAvB,CAA3B;AACA,QAAIW,YAAJ;AACA,QAAIH,mBAAmB8C,GAAnB,CAAuB4C,gBAAvB,CAAJ,EAA8C;AAC5CvF,qBAAeH,mBAAmBC,GAAnB,CAAuByF,gBAAvB,CAAf;AACD,KAFD,MAEO;AACLvF,qBAAe,IAAIwF,0BAAJ,CAAiBnG,SAAjB,EAA4B0C,QAAQmB,KAAR,CAAcuC,KAA1C,EAAiDF,gBAAjD,CAAf;AACA1F,yBAAmB5C,GAAnB,CAAuBsI,gBAAvB,EAAyCvF,YAAzC;AACD;;AAED;AACA,UAAM8C,mBAAmB;AACvB9C,oBAAcA;AADS,KAAzB;AAGA;AACA,QAAI+B,QAAQmB,KAAR,CAAcwC,MAAlB,EAA0B;AACxB5C,uBAAiB4C,MAAjB,GAA0B3D,QAAQmB,KAAR,CAAcwC,MAAxC;AACD;AACD,QAAI3D,QAAQwB,YAAZ,EAA0B;AACxBT,uBAAiBS,YAAjB,GAAgCxB,QAAQwB,YAAxC;AACD;AACD9C,WAAOkF,mBAAP,CAA2B5D,QAAQrB,SAAnC,EAA8CoC,gBAA9C;;AAEA;AACA9C,iBAAa4F,qBAAb,CAAmC7H,eAAeqC,QAAlD,EAA4D2B,QAAQrB,SAApE;;AAEAD,WAAOoF,aAAP,CAAqB9D,QAAQrB,SAA7B;;AAEAxD,qBAAOC,OAAP,CAAgB,iBAAgBY,eAAeqC,QAAS,sBAAqB2B,QAAQrB,SAAU,EAA/F;AACAxD,qBAAOC,OAAP,CAAe,2BAAf,EAA4C,KAAKT,OAAL,CAAakD,IAAzD;AACA,6CAA0B;AACxBgD,aAAO,WADiB;AAExBlG,eAAS,KAAKA,OAAL,CAAakD,IAFE;AAGxBhD,qBAAe,KAAKA,aAAL,CAAmBgD;AAHV,KAA1B;AAKD;;AAED4C,4BAA0BzE,cAA1B,EAA+CgE,OAA/C,EAAkE;AAChE,SAAKU,kBAAL,CAAwB1E,cAAxB,EAAwCgE,OAAxC,EAAiD,KAAjD;AACA,SAAKQ,gBAAL,CAAsBxE,cAAtB,EAAsCgE,OAAtC;AACD;;AAEDU,qBAAmB1E,cAAnB,EAAwCgE,OAAxC,EAAsD+D,eAAqB,IAA3E,EAAsF;AACpF;AACA,QAAI,CAAC/H,eAAeqH,cAAf,CAA8B,UAA9B,CAAL,EAAgD;AAC9ChD,qBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoC,gFAApC;AACAb,uBAAO2B,KAAP,CAAa,gFAAb;AACA;AACD;AACD,UAAM6B,YAAYqB,QAAQrB,SAA1B;AACA,UAAMD,SAAS,KAAK/D,OAAL,CAAaoD,GAAb,CAAiB/B,eAAeqC,QAAhC,CAAf;AACA,QAAI,OAAOK,MAAP,KAAkB,WAAtB,EAAmC;AACjC2B,qBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoC,sCAAuCA,eAAeqC,QAAtD,GAClC,oEADF;AAEAlD,uBAAO2B,KAAP,CAAa,8BAA8Bd,eAAeqC,QAA1D;AACA;AACD;;AAED,UAAM0C,mBAAmBrC,OAAO4C,mBAAP,CAA2B3C,SAA3B,CAAzB;AACA,QAAI,OAAOoC,gBAAP,KAA4B,WAAhC,EAA6C;AAC3CV,qBAAOC,SAAP,CAAiBtE,cAAjB,EAAiC,CAAjC,EAAoC,4CAA6CA,eAAeqC,QAA5D,GAClC,kBADkC,GACbM,SADa,GACD,sEADnC;AAEAxD,uBAAO2B,KAAP,CAAa,6CAA6Cd,eAAeqC,QAA5D,GAAwE,kBAAxE,GAA6FM,SAA1G;AACA;AACD;;AAED;AACAD,WAAOsF,sBAAP,CAA8BrF,SAA9B;AACA;AACA,UAAMV,eAAe8C,iBAAiB9C,YAAtC;AACA,UAAMX,YAAYW,aAAaX,SAA/B;AACAW,iBAAagD,wBAAb,CAAsCjF,eAAeqC,QAArD,EAA+DM,SAA/D;AACA;AACA,UAAMb,qBAAqB,KAAKjD,aAAL,CAAmBkD,GAAnB,CAAuBT,SAAvB,CAA3B;AACA,QAAI,CAACW,aAAaiD,oBAAb,EAAL,EAA0C;AACxCpD,yBAAmBgD,MAAnB,CAA0B7C,aAAa4B,IAAvC;AACD;AACD;AACA,QAAI/B,mBAAmBD,IAAnB,KAA4B,CAAhC,EAAmC;AACjC,WAAKhD,aAAL,CAAmBiG,MAAnB,CAA0BxD,SAA1B;AACD;AACD,6CAA0B;AACxBuD,aAAO,aADiB;AAExBlG,eAAS,KAAKA,OAAL,CAAakD,IAFE;AAGxBhD,qBAAe,KAAKA,aAAL,CAAmBgD;AAHV,KAA1B;;AAMA,QAAI,CAACkG,YAAL,EAAmB;AACjB;AACD;;AAEDrF,WAAOuF,eAAP,CAAuBjE,QAAQrB,SAA/B;;AAEAxD,qBAAOC,OAAP,CAAgB,kBAAiBY,eAAeqC,QAAS,oBAAmB2B,QAAQrB,SAAU,EAA9F;AACD;AA9iBwB;;QAkjBzBpE,oB,GAAAA,oB","file":"ParseLiveQueryServer.js","sourcesContent":["import tv4 from 'tv4';\nimport Parse from 'parse/node';\nimport { Subscription } from './Subscription';\nimport { Client } from './Client';\nimport { ParseWebSocketServer } from './ParseWebSocketServer';\nimport logger from '../logger';\nimport RequestSchema from './RequestSchema';\nimport { matchesQuery, queryHash } from './QueryTools';\nimport { ParsePubSub } from './ParsePubSub';\nimport { SessionTokenCache } from './SessionTokenCache';\nimport _ from 'lodash';\nimport uuid from 'uuid';\nimport { runLiveQueryEventHandlers } from '../triggers';\n\nclass ParseLiveQueryServer {\n  clients: Map;\n  // className -> (queryHash -> subscription)\n  subscriptions: Object;\n  parseWebSocketServer: Object;\n  keyPairs : any;\n  // The subscriber we use to get object update from publisher\n  subscriber: Object;\n\n  constructor(server: any, config: any) {\n    this.server = server;\n    this.clients = new Map();\n    this.subscriptions = new Map();\n\n    config = config || {};\n\n    // Store keys, convert obj to map\n    const keyPairs = config.keyPairs || {};\n    this.keyPairs = new Map();\n    for (const key of Object.keys(keyPairs)) {\n      this.keyPairs.set(key, keyPairs[key]);\n    }\n    logger.verbose('Support key pairs', this.keyPairs);\n\n    // Initialize Parse\n    Parse.Object.disableSingleInstance();\n\n    const serverURL = config.serverURL || Parse.serverURL;\n    Parse.serverURL = serverURL;\n    const appId = config.appId || Parse.applicationId;\n    const javascriptKey = Parse.javaScriptKey;\n    const masterKey = config.masterKey || Parse.masterKey;\n    Parse.initialize(appId, javascriptKey, masterKey);\n\n    // Initialize websocket server\n    this.parseWebSocketServer = new ParseWebSocketServer(\n      server,\n      (parseWebsocket) => this._onConnect(parseWebsocket),\n      config.websocketTimeout\n    );\n\n    // Initialize subscriber\n    this.subscriber = ParsePubSub.createSubscriber(config);\n    this.subscriber.subscribe(Parse.applicationId + 'afterSave');\n    this.subscriber.subscribe(Parse.applicationId + 'afterDelete');\n    // Register message handler for subscriber. When publisher get messages, it will publish message\n    // to the subscribers and the handler will be called.\n    this.subscriber.on('message', (channel, messageStr) => {\n      logger.verbose('Subscribe messsage %j', messageStr);\n      let message;\n      try {\n        message = JSON.parse(messageStr);\n      } catch(e) {\n        logger.error('unable to parse message', messageStr, e);\n        return;\n      }\n      this._inflateParseObject(message);\n      if (channel === Parse.applicationId + 'afterSave') {\n        this._onAfterSave(message);\n      } else if (channel === Parse.applicationId + 'afterDelete') {\n        this._onAfterDelete(message);\n      } else {\n        logger.error('Get message %s from unknown channel %j', message, channel);\n      }\n    });\n\n    // Initialize sessionToken cache\n    this.sessionTokenCache = new SessionTokenCache(config.cacheTimeout);\n  }\n\n  // Message is the JSON object from publisher. Message.currentParseObject is the ParseObject JSON after changes.\n  // Message.originalParseObject is the original ParseObject JSON.\n  _inflateParseObject(message: any): void {\n    // Inflate merged object\n    const currentParseObject = message.currentParseObject;\n    let className = currentParseObject.className;\n    let parseObject = new Parse.Object(className);\n    parseObject._finishFetch(currentParseObject);\n    message.currentParseObject = parseObject;\n    // Inflate original object\n    const originalParseObject = message.originalParseObject;\n    if (originalParseObject) {\n      className = originalParseObject.className;\n      parseObject = new Parse.Object(className);\n      parseObject._finishFetch(originalParseObject);\n      message.originalParseObject = parseObject;\n    }\n  }\n\n  // Message is the JSON object from publisher after inflated. Message.currentParseObject is the ParseObject after changes.\n  // Message.originalParseObject is the original ParseObject.\n  _onAfterDelete(message: any): void {\n    logger.verbose(Parse.applicationId + 'afterDelete is triggered');\n\n    const deletedParseObject = message.currentParseObject.toJSON();\n    const className = deletedParseObject.className;\n    logger.verbose('ClassName: %j | ObjectId: %s', className, deletedParseObject.id);\n    logger.verbose('Current client number : %d', this.clients.size);\n\n    const classSubscriptions = this.subscriptions.get(className);\n    if (typeof classSubscriptions === 'undefined') {\n      logger.debug('Can not find subscriptions under this class ' + className);\n      return;\n    }\n    for (const subscription of classSubscriptions.values()) {\n      const isSubscriptionMatched = this._matchesSubscription(deletedParseObject, subscription);\n      if (!isSubscriptionMatched) {\n        continue;\n      }\n      for (const [clientId, requestIds] of _.entries(subscription.clientRequestIds)) {\n        const client = this.clients.get(clientId);\n        if (typeof client === 'undefined') {\n          continue;\n        }\n        for (const requestId of requestIds) {\n          const acl = message.currentParseObject.getACL();\n          // Check ACL\n          this._matchesACL(acl, client, requestId).then((isMatched) => {\n            if (!isMatched) {\n              return null;\n            }\n            client.pushDelete(requestId, deletedParseObject);\n          }, (error) => {\n            logger.error('Matching ACL error : ', error);\n          });\n        }\n      }\n    }\n  }\n\n  // Message is the JSON object from publisher after inflated. Message.currentParseObject is the ParseObject after changes.\n  // Message.originalParseObject is the original ParseObject.\n  _onAfterSave(message: any): void {\n    logger.verbose(Parse.applicationId + 'afterSave is triggered');\n\n    let originalParseObject = null;\n    if (message.originalParseObject) {\n      originalParseObject = message.originalParseObject.toJSON();\n    }\n    const currentParseObject = message.currentParseObject.toJSON();\n    const className = currentParseObject.className;\n    logger.verbose('ClassName: %s | ObjectId: %s', className, currentParseObject.id);\n    logger.verbose('Current client number : %d', this.clients.size);\n\n    const classSubscriptions = this.subscriptions.get(className);\n    if (typeof classSubscriptions === 'undefined') {\n      logger.debug('Can not find subscriptions under this class ' + className);\n      return;\n    }\n    for (const subscription of classSubscriptions.values()) {\n      const isOriginalSubscriptionMatched = this._matchesSubscription(originalParseObject, subscription);\n      const isCurrentSubscriptionMatched = this._matchesSubscription(currentParseObject, subscription);\n      for (const [clientId, requestIds] of _.entries(subscription.clientRequestIds)) {\n        const client = this.clients.get(clientId);\n        if (typeof client === 'undefined') {\n          continue;\n        }\n        for (const requestId of requestIds) {\n          // Set orignal ParseObject ACL checking promise, if the object does not match\n          // subscription, we do not need to check ACL\n          let originalACLCheckingPromise;\n          if (!isOriginalSubscriptionMatched) {\n            originalACLCheckingPromise = Parse.Promise.as(false);\n          } else {\n            let originalACL;\n            if (message.originalParseObject) {\n              originalACL = message.originalParseObject.getACL();\n            }\n            originalACLCheckingPromise = this._matchesACL(originalACL, client, requestId);\n          }\n          // Set current ParseObject ACL checking promise, if the object does not match\n          // subscription, we do not need to check ACL\n          let currentACLCheckingPromise;\n          if (!isCurrentSubscriptionMatched) {\n            currentACLCheckingPromise = Parse.Promise.as(false);\n          } else {\n            const currentACL = message.currentParseObject.getACL();\n            currentACLCheckingPromise = this._matchesACL(currentACL, client, requestId);\n          }\n\n          Parse.Promise.when(\n            originalACLCheckingPromise,\n            currentACLCheckingPromise\n          ).then((isOriginalMatched, isCurrentMatched) => {\n            logger.verbose('Original %j | Current %j | Match: %s, %s, %s, %s | Query: %s',\n              originalParseObject,\n              currentParseObject,\n              isOriginalSubscriptionMatched,\n              isCurrentSubscriptionMatched,\n              isOriginalMatched,\n              isCurrentMatched,\n              subscription.hash\n            );\n\n            // Decide event type\n            let type;\n            if (isOriginalMatched && isCurrentMatched) {\n              type = 'Update';\n            } else if (isOriginalMatched && !isCurrentMatched) {\n              type = 'Leave';\n            } else if (!isOriginalMatched && isCurrentMatched) {\n              if (originalParseObject) {\n                type = 'Enter';\n              } else {\n                type = 'Create';\n              }\n            } else {\n              return null;\n            }\n            const functionName = 'push' + type;\n            client[functionName](requestId, currentParseObject);\n          }, (error) => {\n            logger.error('Matching ACL error : ', error);\n          });\n        }\n      }\n    }\n  }\n\n  _onConnect(parseWebsocket: any): void {\n    parseWebsocket.on('message', (request) => {\n      if (typeof request === 'string') {\n        try {\n          request = JSON.parse(request);\n        } catch(e) {\n          logger.error('unable to parse request', request, e);\n          return;\n        }\n      }\n      logger.verbose('Request: %j', request);\n\n      // Check whether this request is a valid request, return error directly if not\n      if (!tv4.validate(request, RequestSchema['general']) || !tv4.validate(request, RequestSchema[request.op])) {\n        Client.pushError(parseWebsocket, 1, tv4.error.message);\n        logger.error('Connect message error %s', tv4.error.message);\n        return;\n      }\n\n      switch(request.op) {\n      case 'connect':\n        this._handleConnect(parseWebsocket, request);\n        break;\n      case 'subscribe':\n        this._handleSubscribe(parseWebsocket, request);\n        break;\n      case 'update':\n        this._handleUpdateSubscription(parseWebsocket, request);\n        break;\n      case 'unsubscribe':\n        this._handleUnsubscribe(parseWebsocket, request);\n        break;\n      default:\n        Client.pushError(parseWebsocket, 3, 'Get unknown operation');\n        logger.error('Get unknown operation', request.op);\n      }\n    });\n\n    parseWebsocket.on('disconnect', () => {\n      logger.info(`Client disconnect: ${parseWebsocket.clientId}`);\n      const clientId = parseWebsocket.clientId;\n      if (!this.clients.has(clientId)) {\n        runLiveQueryEventHandlers({\n          event: 'ws_disconnect_error',\n          clients: this.clients.size,\n          subscriptions: this.subscriptions.size,\n          error: `Unable to find client ${clientId}`\n        });\n        logger.error(`Can not find client ${clientId} on disconnect`);\n        return;\n      }\n\n      // Delete client\n      const client = this.clients.get(clientId);\n      this.clients.delete(clientId);\n\n      // Delete client from subscriptions\n      for (const [requestId, subscriptionInfo] of _.entries(client.subscriptionInfos)) {\n        const subscription = subscriptionInfo.subscription;\n        subscription.deleteClientSubscription(clientId, requestId);\n\n        // If there is no client which is subscribing this subscription, remove it from subscriptions\n        const classSubscriptions = this.subscriptions.get(subscription.className);\n        if (!subscription.hasSubscribingClient()) {\n          classSubscriptions.delete(subscription.hash);\n        }\n        // If there is no subscriptions under this class, remove it from subscriptions\n        if (classSubscriptions.size === 0) {\n          this.subscriptions.delete(subscription.className);\n        }\n      }\n\n      logger.verbose('Current clients %d', this.clients.size);\n      logger.verbose('Current subscriptions %d', this.subscriptions.size);\n      runLiveQueryEventHandlers({\n        event: 'ws_disconnect',\n        clients: this.clients.size,\n        subscriptions: this.subscriptions.size\n      });\n    });\n\n    runLiveQueryEventHandlers({\n      event: 'ws_connect',\n      clients: this.clients.size,\n      subscriptions: this.subscriptions.size\n    });\n  }\n\n  _matchesSubscription(parseObject: any, subscription: any): boolean {\n    // Object is undefined or null, not match\n    if (!parseObject) {\n      return false;\n    }\n    return matchesQuery(parseObject, subscription.query);\n  }\n\n  _matchesACL(acl: any, client: any, requestId: number): any {\n    // Return true directly if ACL isn't present, ACL is public read, or client has master key\n    if (!acl || acl.getPublicReadAccess() || client.hasMasterKey) {\n      return Parse.Promise.as(true);\n    }\n    // Check subscription sessionToken matches ACL first\n    const subscriptionInfo = client.getSubscriptionInfo(requestId);\n    if (typeof subscriptionInfo === 'undefined') {\n      return Parse.Promise.as(false);\n    }\n\n    const subscriptionSessionToken = subscriptionInfo.sessionToken;\n    return this.sessionTokenCache.getUserId(subscriptionSessionToken).then((userId) => {\n      return acl.getReadAccess(userId);\n    }).then((isSubscriptionSessionTokenMatched) => {\n      if (isSubscriptionSessionTokenMatched) {\n        return Parse.Promise.as(true);\n      }\n\n      // Check if the user has any roles that match the ACL\n      return new Parse.Promise((resolve, reject) => {\n\n        // Resolve false right away if the acl doesn't have any roles\n        const acl_has_roles = Object.keys(acl.permissionsById).some(key => key.startsWith(\"role:\"));\n        if (!acl_has_roles) {\n          return resolve(false);\n        }\n\n        this.sessionTokenCache.getUserId(subscriptionSessionToken)\n          .then((userId) => {\n\n            // Pass along a null if there is no user id\n            if (!userId) {\n              return Parse.Promise.as(null);\n            }\n\n            // Prepare a user object to query for roles\n            // To eliminate a query for the user, create one locally with the id\n            var user = new Parse.User();\n            user.id = userId;\n            return user;\n\n          })\n          .then((user) => {\n\n            // Pass along an empty array (of roles) if no user\n            if (!user) {\n              return Parse.Promise.as([]);\n            }\n\n            // Then get the user's roles\n            var rolesQuery = new Parse.Query(Parse.Role);\n            rolesQuery.equalTo(\"users\", user);\n            return rolesQuery.find({useMasterKey:true});\n          }).\n          then((roles) => {\n\n            // Finally, see if any of the user's roles allow them read access\n            for (const role of roles) {\n              if (acl.getRoleReadAccess(role)) {\n                return resolve(true);\n              }\n            }\n            resolve(false);\n          })\n          .catch((error) => {\n            reject(error);\n          });\n\n      });\n    }).then((isRoleMatched) => {\n\n      if(isRoleMatched) {\n        return Parse.Promise.as(true);\n      }\n\n      // Check client sessionToken matches ACL\n      const clientSessionToken = client.sessionToken;\n      return this.sessionTokenCache.getUserId(clientSessionToken).then((userId) => {\n        return acl.getReadAccess(userId);\n      });\n    }).then((isMatched) => {\n      return Parse.Promise.as(isMatched);\n    }, () => {\n      return Parse.Promise.as(false);\n    });\n  }\n\n  _handleConnect(parseWebsocket: any, request: any): any {\n    if (!this._validateKeys(request, this.keyPairs)) {\n      Client.pushError(parseWebsocket, 4, 'Key in request is not valid');\n      logger.error('Key in request is not valid');\n      return;\n    }\n    const hasMasterKey = this._hasMasterKey(request, this.keyPairs);\n    const clientId = uuid();\n    const client = new Client(clientId, parseWebsocket, hasMasterKey);\n    parseWebsocket.clientId = clientId;\n    this.clients.set(parseWebsocket.clientId, client);\n    logger.info(`Create new client: ${parseWebsocket.clientId}`);\n    client.pushConnect();\n    runLiveQueryEventHandlers({\n      event: 'connect',\n      clients: this.clients.size,\n      subscriptions: this.subscriptions.size\n    });\n  }\n\n  _hasMasterKey(request: any, validKeyPairs: any): boolean {\n    if(!validKeyPairs || validKeyPairs.size == 0 ||\n      !validKeyPairs.has(\"masterKey\")) {\n      return false;\n    }\n    if(!request || !request.hasOwnProperty(\"masterKey\")) {\n      return false;\n    }\n    return request.masterKey === validKeyPairs.get(\"masterKey\");\n  }\n\n  _validateKeys(request: any, validKeyPairs: any): boolean {\n    if (!validKeyPairs || validKeyPairs.size == 0) {\n      return true;\n    }\n    let isValid = false;\n    for (const [key, secret] of validKeyPairs) {\n      if (!request[key] || request[key] !== secret) {\n        continue;\n      }\n      isValid = true;\n      break;\n    }\n    return isValid;\n  }\n\n  _handleSubscribe(parseWebsocket: any, request: any): any {\n    // If we can not find this client, return error to client\n    if (!parseWebsocket.hasOwnProperty('clientId')) {\n      Client.pushError(parseWebsocket, 2, 'Can not find this client, make sure you connect to server before subscribing');\n      logger.error('Can not find this client, make sure you connect to server before subscribing');\n      return;\n    }\n    const client = this.clients.get(parseWebsocket.clientId);\n\n    // Get subscription from subscriptions, create one if necessary\n    const subscriptionHash = queryHash(request.query);\n    // Add className to subscriptions if necessary\n    const className = request.query.className;\n    if (!this.subscriptions.has(className)) {\n      this.subscriptions.set(className, new Map());\n    }\n    const classSubscriptions = this.subscriptions.get(className);\n    let subscription;\n    if (classSubscriptions.has(subscriptionHash)) {\n      subscription = classSubscriptions.get(subscriptionHash);\n    } else {\n      subscription = new Subscription(className, request.query.where, subscriptionHash);\n      classSubscriptions.set(subscriptionHash, subscription);\n    }\n\n    // Add subscriptionInfo to client\n    const subscriptionInfo = {\n      subscription: subscription\n    };\n    // Add selected fields and sessionToken for this subscription if necessary\n    if (request.query.fields) {\n      subscriptionInfo.fields = request.query.fields;\n    }\n    if (request.sessionToken) {\n      subscriptionInfo.sessionToken = request.sessionToken;\n    }\n    client.addSubscriptionInfo(request.requestId, subscriptionInfo);\n\n    // Add clientId to subscription\n    subscription.addClientSubscription(parseWebsocket.clientId, request.requestId);\n\n    client.pushSubscribe(request.requestId);\n\n    logger.verbose(`Create client ${parseWebsocket.clientId} new subscription: ${request.requestId}`);\n    logger.verbose('Current client number: %d', this.clients.size);\n    runLiveQueryEventHandlers({\n      event: 'subscribe',\n      clients: this.clients.size,\n      subscriptions: this.subscriptions.size\n    });\n  }\n\n  _handleUpdateSubscription(parseWebsocket: any, request: any): any {\n    this._handleUnsubscribe(parseWebsocket, request, false);\n    this._handleSubscribe(parseWebsocket, request);\n  }\n\n  _handleUnsubscribe(parseWebsocket: any, request: any, notifyClient: bool = true): any {\n    // If we can not find this client, return error to client\n    if (!parseWebsocket.hasOwnProperty('clientId')) {\n      Client.pushError(parseWebsocket, 2, 'Can not find this client, make sure you connect to server before unsubscribing');\n      logger.error('Can not find this client, make sure you connect to server before unsubscribing');\n      return;\n    }\n    const requestId = request.requestId;\n    const client = this.clients.get(parseWebsocket.clientId);\n    if (typeof client === 'undefined') {\n      Client.pushError(parseWebsocket, 2, 'Cannot find client with clientId '  + parseWebsocket.clientId +\n        '. Make sure you connect to live query server before unsubscribing.');\n      logger.error('Can not find this client ' + parseWebsocket.clientId);\n      return;\n    }\n\n    const subscriptionInfo = client.getSubscriptionInfo(requestId);\n    if (typeof subscriptionInfo === 'undefined') {\n      Client.pushError(parseWebsocket, 2, 'Cannot find subscription with clientId '  + parseWebsocket.clientId +\n        ' subscriptionId ' + requestId + '. Make sure you subscribe to live query server before unsubscribing.');\n      logger.error('Can not find subscription with clientId ' + parseWebsocket.clientId +  ' subscriptionId ' + requestId);\n      return;\n    }\n\n    // Remove subscription from client\n    client.deleteSubscriptionInfo(requestId);\n    // Remove client from subscription\n    const subscription = subscriptionInfo.subscription;\n    const className = subscription.className;\n    subscription.deleteClientSubscription(parseWebsocket.clientId, requestId);\n    // If there is no client which is subscribing this subscription, remove it from subscriptions\n    const classSubscriptions = this.subscriptions.get(className);\n    if (!subscription.hasSubscribingClient()) {\n      classSubscriptions.delete(subscription.hash);\n    }\n    // If there is no subscriptions under this class, remove it from subscriptions\n    if (classSubscriptions.size === 0) {\n      this.subscriptions.delete(className);\n    }\n    runLiveQueryEventHandlers({\n      event: 'unsubscribe',\n      clients: this.clients.size,\n      subscriptions: this.subscriptions.size\n    });\n\n    if (!notifyClient) {\n      return;\n    }\n\n    client.pushUnsubscribe(request.requestId);\n\n    logger.verbose(`Delete client: ${parseWebsocket.clientId} | subscription: ${request.requestId}`);\n  }\n}\n\nexport {\n  ParseLiveQueryServer\n}\n"]} \ No newline at end of file diff --git a/lib/LiveQuery/ParsePubSub.js b/lib/LiveQuery/ParsePubSub.js index 6686db2607..624907f58e 100644 --- a/lib/LiveQuery/ParsePubSub.js +++ b/lib/LiveQuery/ParsePubSub.js @@ -42,4 +42,5 @@ ParsePubSub.createSubscriber = function (config) { } }; -exports.ParsePubSub = ParsePubSub; \ No newline at end of file +exports.ParsePubSub = ParsePubSub; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/LiveQuery/ParseWebSocketServer.js b/lib/LiveQuery/ParseWebSocketServer.js index f59723886c..7c4e8f4e0f 100644 --- a/lib/LiveQuery/ParseWebSocketServer.js +++ b/lib/LiveQuery/ParseWebSocketServer.js @@ -59,4 +59,5 @@ class ParseWebSocket { this.ws.send(message); } } -exports.ParseWebSocket = ParseWebSocket; \ No newline at end of file +exports.ParseWebSocket = ParseWebSocket; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/LiveQuery/QueryTools.js b/lib/LiveQuery/QueryTools.js index 74d528c8f8..905c842d00 100644 --- a/lib/LiveQuery/QueryTools.js +++ b/lib/LiveQuery/QueryTools.js @@ -317,4 +317,5 @@ var QueryTools = { matchesQuery: matchesQuery }; -module.exports = QueryTools; \ No newline at end of file +module.exports = QueryTools; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LiveQuery/QueryTools.js"],"names":["equalObjects","require","Id","Parse","flattenOrQueries","where","hasOwnProperty","accum","i","$or","length","concat","stringify","object","replace","Array","isArray","copy","map","sort","join","sections","keys","Object","k","push","queryHash","query","Query","className","_where","columns","values","uniqueColumns","subValues","j","contains","haystack","needle","__type","ptr","objectId","indexOf","matchesQuery","id","field","matchesKeyConstraints","equalObjectsGeneric","obj","compareTo","eqlFn","key","constraints","keyComponents","split","subObjectKey","keyRemainder","slice","_decode","condition","propertyExists","existenceIsRequired","test","expString","escapeEnd","escapeStart","substring","Math","max","exp","RegExp","$options","distance","radiansTo","$maxDistance","Infinity","southWest","$box","northEast","latitude","longitude","QueryTools","module","exports"],"mappings":"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","file":"QueryTools.js","sourcesContent":["var equalObjects = require('./equalObjects');\nvar Id = require('./Id');\nvar Parse = require('parse/node');\n\n/**\n * Query Hashes are deterministic hashes for Parse Queries.\n * Any two queries that have the same set of constraints will produce the same\n * hash. This lets us reliably group components by the queries they depend upon,\n * and quickly determine if a query has changed.\n */\n\n/**\n * Convert $or queries into an array of where conditions\n */\nfunction flattenOrQueries(where) {\n  if (!where.hasOwnProperty('$or')) {\n    return where;\n  }\n  var accum = [];\n  for (var i = 0; i < where.$or.length; i++) {\n    accum = accum.concat(where.$or[i]);\n  }\n  return accum;\n}\n\n/**\n * Deterministically turns an object into a string. Disregards ordering\n */\nfunction stringify(object): string {\n  if (typeof object !== 'object' || object === null) {\n    if (typeof object === 'string') {\n      return '\"' + object.replace(/\\|/g, '%|') + '\"';\n    }\n    return object + '';\n  }\n  if (Array.isArray(object)) {\n    var copy = object.map(stringify);\n    copy.sort();\n    return '[' + copy.join(',') + ']';\n  }\n  var sections = [];\n  var keys = Object.keys(object);\n  keys.sort();\n  for (var k = 0; k < keys.length; k++) {\n    sections.push(stringify(keys[k]) + ':' + stringify(object[keys[k]]));\n  }\n  return '{' + sections.join(',') + '}';\n}\n\n/**\n * Generate a hash from a query, with unique fields for columns, values, order,\n * skip, and limit.\n */\nfunction queryHash(query) {\n  if (query instanceof Parse.Query) {\n    query = {\n      className: query.className,\n      where: query._where\n    }\n  }\n  var where = flattenOrQueries(query.where || {});\n  var columns = [];\n  var values = [];\n  var i;\n  if (Array.isArray(where)) {\n    var uniqueColumns = {};\n    for (i = 0; i < where.length; i++) {\n      var subValues = {};\n      var keys = Object.keys(where[i]);\n      keys.sort();\n      for (var j = 0; j < keys.length; j++) {\n        subValues[keys[j]] = where[i][keys[j]];\n        uniqueColumns[keys[j]] = true;\n      }\n      values.push(subValues);\n    }\n    columns = Object.keys(uniqueColumns);\n    columns.sort();\n  } else {\n    columns = Object.keys(where);\n    columns.sort();\n    for (i = 0; i < columns.length; i++) {\n      values.push(where[columns[i]]);\n    }\n  }\n\n  var sections = [columns.join(','), stringify(values)];\n\n  return query.className + ':' + sections.join('|');\n}\n\n/**\n * contains -- Determines if an object is contained in a list with special handling for Parse pointers.\n */\nfunction contains(haystack: Array, needle: any): boolean {\n  if (needle && needle.__type && needle.__type === 'Pointer') {\n    for (const i in haystack) {\n      const ptr = haystack[i];\n      if (typeof ptr === 'string' && ptr === needle.objectId) {\n        return true;\n      }\n      if (ptr.className === needle.className &&\n          ptr.objectId === needle.objectId) {\n        return true;\n      }\n    }\n    return false;\n  }\n  return haystack.indexOf(needle) > -1;\n}\n/**\n * matchesQuery -- Determines if an object would be returned by a Parse Query\n * It's a lightweight, where-clause only implementation of a full query engine.\n * Since we find queries that match objects, rather than objects that match\n * queries, we can avoid building a full-blown query tool.\n */\nfunction matchesQuery(object: any, query: any): boolean {\n  if (query instanceof Parse.Query) {\n    var className =\n      (object.id instanceof Id) ? object.id.className : object.className;\n    if (className !== query.className) {\n      return false;\n    }\n    return matchesQuery(object, query._where);\n  }\n  for (var field in query) {\n    if (!matchesKeyConstraints(object, field, query[field])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction equalObjectsGeneric(obj, compareTo, eqlFn) {\n  if (Array.isArray(obj)) {\n    for (var i = 0; i < obj.length; i++) {\n      if (eqlFn(obj[i], compareTo)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return eqlFn(obj, compareTo);\n}\n\n\n/**\n * Determines whether an object matches a single key's constraints\n */\nfunction matchesKeyConstraints(object, key, constraints) {\n  if (constraints === null) {\n    return false;\n  }\n  if(key.indexOf(\".\") >= 0){\n    // Key references a subobject\n    var keyComponents = key.split(\".\");\n    var subObjectKey = keyComponents[0];\n    var keyRemainder = keyComponents.slice(1).join(\".\");\n    return matchesKeyConstraints(object[subObjectKey] || {}, keyRemainder, constraints);\n  }\n  var i;\n  if (key === '$or') {\n    for (i = 0; i < constraints.length; i++) {\n      if (matchesQuery(object, constraints[i])) {\n        return true;\n      }\n    }\n    return false;\n  }\n  if (key === '$relatedTo') {\n    // Bail! We can't handle relational queries locally\n    return false;\n  }\n  // Equality (or Array contains) cases\n  if (typeof constraints !== 'object') {\n    if (Array.isArray(object[key])) {\n      return object[key].indexOf(constraints) > -1;\n    }\n    return object[key] === constraints;\n  }\n  var compareTo;\n  if (constraints.__type) {\n    if (constraints.__type === 'Pointer') {\n      return equalObjectsGeneric(object[key], constraints, function(obj, ptr) {\n        return (\n          typeof obj !== 'undefined' &&\n          ptr.className === obj.className &&\n          ptr.objectId === obj.objectId\n        );\n      });\n    }\n\n    return equalObjectsGeneric(object[key], Parse._decode(key, constraints), equalObjects);\n  }\n  // More complex cases\n  for (var condition in constraints) {\n    compareTo = constraints[condition];\n    if (compareTo.__type) {\n      compareTo = Parse._decode(key, compareTo);\n    }\n    switch (condition) {\n    case '$lt':\n      if (object[key] >= compareTo) {\n        return false;\n      }\n      break;\n    case '$lte':\n      if (object[key] > compareTo) {\n        return false;\n      }\n      break;\n    case '$gt':\n      if (object[key] <= compareTo) {\n        return false;\n      }\n      break;\n    case '$gte':\n      if (object[key] < compareTo) {\n        return false;\n      }\n      break;\n    case '$ne':\n      if (equalObjects(object[key], compareTo)) {\n        return false;\n      }\n      break;\n    case '$in':\n      if (!contains(compareTo, object[key])) {\n        return false;\n      }\n      break;\n    case '$nin':\n      if (contains(compareTo, object[key])) {\n        return false;\n      }\n      break;\n    case '$all':\n      for (i = 0; i < compareTo.length; i++) {\n        if (object[key].indexOf(compareTo[i]) < 0) {\n          return false;\n        }\n      }\n      break;\n    case '$exists': {\n      const propertyExists = typeof object[key] !== 'undefined';\n      const existenceIsRequired = constraints['$exists'];\n      if (typeof constraints['$exists'] !== 'boolean') {\n        // The SDK will never submit a non-boolean for $exists, but if someone\n        // tries to submit a non-boolean for $exits outside the SDKs, just ignore it.\n        break;\n      }\n      if ((!propertyExists && existenceIsRequired) || (propertyExists && !existenceIsRequired)) {\n        return false;\n      }\n      break;\n    }\n    case '$regex':\n      if (typeof compareTo === 'object') {\n        return compareTo.test(object[key]);\n      }\n      // JS doesn't support perl-style escaping\n      var expString = '';\n      var escapeEnd = -2;\n      var escapeStart = compareTo.indexOf('\\\\Q');\n      while (escapeStart > -1) {\n        // Add the unescaped portion\n        expString += compareTo.substring(escapeEnd + 2, escapeStart);\n        escapeEnd = compareTo.indexOf('\\\\E', escapeStart);\n        if (escapeEnd > -1) {\n          expString += compareTo.substring(escapeStart + 2, escapeEnd)\n            .replace(/\\\\\\\\\\\\\\\\E/g, '\\\\E').replace(/\\W/g, '\\\\$&');\n        }\n\n        escapeStart = compareTo.indexOf('\\\\Q', escapeEnd);\n      }\n      expString += compareTo.substring(Math.max(escapeStart, escapeEnd + 2));\n      var exp = new RegExp(expString, constraints.$options || '');\n      if (!exp.test(object[key])) {\n        return false;\n      }\n      break;\n    case '$nearSphere':\n      if (!compareTo || !object[key]) {\n        return false;\n      }\n      var distance = compareTo.radiansTo(object[key]);\n      var max = constraints.$maxDistance || Infinity;\n      return distance <= max;\n    case '$within':\n      if (!compareTo || !object[key]) {\n        return false;\n      }\n      var southWest = compareTo.$box[0];\n      var northEast = compareTo.$box[1];\n      if (southWest.latitude > northEast.latitude ||\n            southWest.longitude > northEast.longitude) {\n        // Invalid box, crosses the date line\n        return false;\n      }\n      return (\n        object[key].latitude > southWest.latitude &&\n          object[key].latitude < northEast.latitude &&\n          object[key].longitude > southWest.longitude &&\n          object[key].longitude < northEast.longitude\n      );\n    case '$options':\n      // Not a query type, but a way to add options to $regex. Ignore and\n      // avoid the default\n      break;\n    case '$maxDistance':\n      // Not a query type, but a way to add a cap to $nearSphere. Ignore and\n      // avoid the default\n      break;\n    case '$select':\n      return false;\n    case '$dontSelect':\n      return false;\n    default:\n      return false;\n    }\n  }\n  return true;\n}\n\nvar QueryTools = {\n  queryHash: queryHash,\n  matchesQuery: matchesQuery\n};\n\nmodule.exports = QueryTools;\n"]} \ No newline at end of file diff --git a/lib/LiveQuery/RequestSchema.js b/lib/LiveQuery/RequestSchema.js index c77f974c74..3c10e0706e 100644 --- a/lib/LiveQuery/RequestSchema.js +++ b/lib/LiveQuery/RequestSchema.js @@ -143,4 +143,5 @@ const RequestSchema = { 'unsubscribe': unsubscribe }; -exports.default = RequestSchema; \ No newline at end of file +exports.default = RequestSchema; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/LiveQuery/SessionTokenCache.js b/lib/LiveQuery/SessionTokenCache.js index 82056f7439..943eb311f6 100644 --- a/lib/LiveQuery/SessionTokenCache.js +++ b/lib/LiveQuery/SessionTokenCache.js @@ -60,4 +60,5 @@ class SessionTokenCache { } } -exports.SessionTokenCache = SessionTokenCache; \ No newline at end of file +exports.SessionTokenCache = SessionTokenCache; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/LiveQuery/Subscription.js b/lib/LiveQuery/Subscription.js index 8d0019fda0..b8dc38ebbd 100644 --- a/lib/LiveQuery/Subscription.js +++ b/lib/LiveQuery/Subscription.js @@ -52,4 +52,5 @@ class Subscription { } } -exports.Subscription = Subscription; \ No newline at end of file +exports.Subscription = Subscription; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/LiveQuery/equalObjects.js b/lib/LiveQuery/equalObjects.js index bb3890a748..3eff04956b 100644 --- a/lib/LiveQuery/equalObjects.js +++ b/lib/LiveQuery/equalObjects.js @@ -47,4 +47,5 @@ function equalObjects(a, b) { return true; } -module.exports = equalObjects; \ No newline at end of file +module.exports = equalObjects; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Options/Definitions.js b/lib/Options/Definitions.js index ae080de808..1b9881ff00 100644 --- a/lib/Options/Definitions.js +++ b/lib/Options/Definitions.js @@ -135,6 +135,12 @@ module.exports.ParseServerOptions = { "env": "PARSE_SERVER_FILE_KEY", "help": "Key for your files" }, + "preserveFileName": { + "env": "PARSE_SERVER_PRESERVE_FILE_NAME", + "help": "Enable (or disable) the addition of a unique hash to the file names", + "action": parsers.booleanParser, + "default": false + }, "userSensitiveFields": { "env": "PARSE_SERVER_USER_SENSITIVE_FIELDS", "help": "Personally identifiable information fields in the user table the should be removed for non-authorized users.", @@ -262,6 +268,12 @@ module.exports.ParseServerOptions = { "action": parsers.booleanParser, "default": false }, + "enableExpressErrorHandler": { + "env": "PARSE_SERVER_ENABLE_EXPRESS_ERROR_HANDLER", + "help": "Enables the default express error handler for all errors", + "action": parsers.booleanParser, + "default": false + }, "objectIdSize": { "env": "PARSE_SERVER_OBJECT_ID_SIZE", "help": "Sets the number of characters in generated object id's, default 10", @@ -385,4 +397,5 @@ module.exports.LiveQueryServerOptions = { "help": "LiveQuery pubsub adapter", "action": parsers.moduleOrObjectParser } -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Options/Definitions.js"],"names":["parsers","require","module","exports","ParseServerOptions","arrayParser","moduleOrObjectParser","objectParser","booleanParser","numberParser","numberOrBooleanParser","CustomPagesOptions","LiveQueryOptions","LiveQueryServerOptions"],"mappings":"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","file":"Definitions.js","sourcesContent":["/*\n**** GENERATED CODE ****\nThis code has been generated by resources/buildConfigDefinitions.js\nDo not edit manually, but update Options/index.js\n*/\"use strict\";\n\nvar parsers = require(\"./parsers\");\n\nmodule.exports.ParseServerOptions = {\n  \"appId\": {\n    \"env\": \"PARSE_SERVER_APPLICATION_ID\",\n    \"help\": \"Your Parse Application ID\",\n    \"required\": true\n  },\n  \"masterKey\": {\n    \"env\": \"PARSE_SERVER_MASTER_KEY\",\n    \"help\": \"Your Parse Master Key\",\n    \"required\": true\n  },\n  \"serverURL\": {\n    \"env\": \"PARSE_SERVER_URL\",\n    \"help\": \"URL to your parse server with http:// or https://.\",\n    \"required\": true\n  },\n  \"masterKeyIps\": {\n    \"env\": \"PARSE_SERVER_MASTER_KEY_IPS\",\n    \"help\": \"Restrict masterKey to be used by only these ips. defaults to [] (allow all ips)\",\n    \"action\": parsers.arrayParser,\n    \"default\": []\n  },\n  \"appName\": {\n    \"env\": \"PARSE_SERVER_APP_NAME\",\n    \"help\": \"Sets the app name\"\n  },\n  \"analyticsAdapter\": {\n    \"env\": \"PARSE_SERVER_ANALYTICS_ADAPTER\",\n    \"help\": \"Adapter module for the analytics\",\n    \"action\": parsers.moduleOrObjectParser\n  },\n  \"filesAdapter\": {\n    \"env\": \"PARSE_SERVER_FILES_ADAPTER\",\n    \"help\": \"Adapter module for the files sub-system\",\n    \"action\": parsers.moduleOrObjectParser\n  },\n  \"push\": {\n    \"env\": \"PARSE_SERVER_PUSH\",\n    \"help\": \"Configuration for push, as stringified JSON. See http://docs.parseplatform.org/parse-server/guide/#push-notifications\",\n    \"action\": parsers.objectParser\n  },\n  \"scheduledPush\": {\n    \"env\": \"PARSE_SERVER_SCHEDULED_PUSH\",\n    \"help\": \"Configuration for push scheduling. Defaults to false.\",\n    \"action\": parsers.booleanParser,\n    \"default\": false\n  },\n  \"loggerAdapter\": {\n    \"env\": \"PARSE_SERVER_LOGGER_ADAPTER\",\n    \"help\": \"Adapter module for the logging sub-system\",\n    \"action\": parsers.moduleOrObjectParser\n  },\n  \"jsonLogs\": {\n    \"env\": \"JSON_LOGS\",\n    \"help\": \"Log as structured JSON objects\",\n    \"action\": parsers.booleanParser\n  },\n  \"logsFolder\": {\n    \"env\": \"PARSE_SERVER_LOGS_FOLDER\",\n    \"help\": \"Folder for the logs (defaults to './logs'); set to null to disable file based logging\",\n    \"default\": \"./logs\"\n  },\n  \"verbose\": {\n    \"env\": \"VERBOSE\",\n    \"help\": \"Set the logging to verbose\",\n    \"action\": parsers.booleanParser\n  },\n  \"logLevel\": {\n    \"env\": \"PARSE_SERVER_LOG_LEVEL\",\n    \"help\": \"Sets the level for logs\"\n  },\n  \"silent\": {\n    \"env\": \"SILENT\",\n    \"help\": \"Disables console output\",\n    \"action\": parsers.booleanParser\n  },\n  \"databaseURI\": {\n    \"env\": \"PARSE_SERVER_DATABASE_URI\",\n    \"help\": \"The full URI to your mongodb database\",\n    \"required\": true,\n    \"default\": \"mongodb://localhost:27017/parse\"\n  },\n  \"databaseOptions\": {\n    \"env\": \"PARSE_SERVER_DATABASE_OPTIONS\",\n    \"help\": \"Options to pass to the mongodb client\",\n    \"action\": parsers.objectParser\n  },\n  \"databaseAdapter\": {\n    \"env\": \"PARSE_SERVER_DATABASE_ADAPTER\",\n    \"help\": \"Adapter module for the database\",\n    \"action\": parsers.moduleOrObjectParser\n  },\n  \"cloud\": {\n    \"env\": \"PARSE_SERVER_CLOUD\",\n    \"help\": \"Full path to your cloud code main.js\"\n  },\n  \"collectionPrefix\": {\n    \"env\": \"PARSE_SERVER_COLLECTION_PREFIX\",\n    \"help\": \"A collection prefix for the classes\",\n    \"default\": \"\"\n  },\n  \"clientKey\": {\n    \"env\": \"PARSE_SERVER_CLIENT_KEY\",\n    \"help\": \"Key for iOS, MacOS, tvOS clients\"\n  },\n  \"javascriptKey\": {\n    \"env\": \"PARSE_SERVER_JAVASCRIPT_KEY\",\n    \"help\": \"Key for the Javascript SDK\"\n  },\n  \"dotNetKey\": {\n    \"env\": \"PARSE_SERVER_DOT_NET_KEY\",\n    \"help\": \"Key for Unity and .Net SDK\"\n  },\n  \"restAPIKey\": {\n    \"env\": \"PARSE_SERVER_REST_API_KEY\",\n    \"help\": \"Key for REST calls\"\n  },\n  \"readOnlyMasterKey\": {\n    \"env\": \"PARSE_SERVER_READ_ONLY_MASTER_KEY\",\n    \"help\": \"Read-only key, which has the same capabilities as MasterKey without writes\"\n  },\n  \"webhookKey\": {\n    \"env\": \"PARSE_SERVER_WEBHOOK_KEY\",\n    \"help\": \"Key sent with outgoing webhook calls\"\n  },\n  \"fileKey\": {\n    \"env\": \"PARSE_SERVER_FILE_KEY\",\n    \"help\": \"Key for your files\"\n  },\n  \"preserveFileName\": {\n    \"env\": \"PARSE_SERVER_PRESERVE_FILE_NAME\",\n    \"help\": \"Enable (or disable) the addition of a unique hash to the file names\",\n    \"action\": parsers.booleanParser,\n    \"default\": false\n  },\n  \"userSensitiveFields\": {\n    \"env\": \"PARSE_SERVER_USER_SENSITIVE_FIELDS\",\n    \"help\": \"Personally identifiable information fields in the user table the should be removed for non-authorized users.\",\n    \"action\": parsers.arrayParser,\n    \"default\": [\"email\"]\n  },\n  \"enableAnonymousUsers\": {\n    \"env\": \"PARSE_SERVER_ENABLE_ANON_USERS\",\n    \"help\": \"Enable (or disable) anon users, defaults to true\",\n    \"action\": parsers.booleanParser,\n    \"default\": true\n  },\n  \"allowClientClassCreation\": {\n    \"env\": \"PARSE_SERVER_ALLOW_CLIENT_CLASS_CREATION\",\n    \"help\": \"Enable (or disable) client class creation, defaults to true\",\n    \"action\": parsers.booleanParser,\n    \"default\": true\n  },\n  \"auth\": {\n    \"env\": \"PARSE_SERVER_AUTH_PROVIDERS\",\n    \"help\": \"Configuration for your authentication providers, as stringified JSON. See http://docs.parseplatform.org/parse-server/guide/#oauth-and-3rd-party-authentication\",\n    \"action\": parsers.objectParser\n  },\n  \"maxUploadSize\": {\n    \"env\": \"PARSE_SERVER_MAX_UPLOAD_SIZE\",\n    \"help\": \"Max file size for uploads. defaults to 20mb\",\n    \"default\": \"20mb\"\n  },\n  \"verifyUserEmails\": {\n    \"env\": \"PARSE_SERVER_VERIFY_USER_EMAILS\",\n    \"help\": \"Enable (or disable) user email validation, defaults to false\",\n    \"action\": parsers.booleanParser,\n    \"default\": false\n  },\n  \"preventLoginWithUnverifiedEmail\": {\n    \"env\": \"PARSE_SERVER_PREVENT_LOGIN_WITH_UNVERIFIED_EMAIL\",\n    \"help\": \"Prevent user from login if email is not verified and PARSE_SERVER_VERIFY_USER_EMAILS is true, defaults to false\",\n    \"action\": parsers.booleanParser,\n    \"default\": false\n  },\n  \"emailVerifyTokenValidityDuration\": {\n    \"env\": \"PARSE_SERVER_EMAIL_VERIFY_TOKEN_VALIDITY_DURATION\",\n    \"help\": \"Email verification token validity duration\",\n    \"action\": parsers.numberParser(\"emailVerifyTokenValidityDuration\")\n  },\n  \"accountLockout\": {\n    \"env\": \"PARSE_SERVER_ACCOUNT_LOCKOUT\",\n    \"help\": \"account lockout policy for failed login attempts\",\n    \"action\": parsers.objectParser\n  },\n  \"passwordPolicy\": {\n    \"env\": \"PARSE_SERVER_PASSWORD_POLICY\",\n    \"help\": \"Password policy for enforcing password related rules\",\n    \"action\": parsers.objectParser\n  },\n  \"cacheAdapter\": {\n    \"env\": \"PARSE_SERVER_CACHE_ADAPTER\",\n    \"help\": \"Adapter module for the cache\",\n    \"action\": parsers.moduleOrObjectParser\n  },\n  \"emailAdapter\": {\n    \"env\": \"PARSE_SERVER_EMAIL_ADAPTER\",\n    \"help\": \"Adapter module for the email sending\",\n    \"action\": parsers.moduleOrObjectParser\n  },\n  \"publicServerURL\": {\n    \"env\": \"PARSE_PUBLIC_SERVER_URL\",\n    \"help\": \"Public URL to your parse server with http:// or https://.\"\n  },\n  \"customPages\": {\n    \"env\": \"PARSE_SERVER_CUSTOM_PAGES\",\n    \"help\": \"custom pages for password validation and reset\",\n    \"action\": parsers.objectParser,\n    \"default\": {}\n  },\n  \"liveQuery\": {\n    \"env\": \"PARSE_SERVER_LIVE_QUERY\",\n    \"help\": \"parse-server's LiveQuery configuration object\",\n    \"action\": parsers.objectParser\n  },\n  \"sessionLength\": {\n    \"env\": \"PARSE_SERVER_SESSION_LENGTH\",\n    \"help\": \"Session duration, in seconds, defaults to 1 year\",\n    \"action\": parsers.numberParser(\"sessionLength\"),\n    \"default\": 31536000\n  },\n  \"maxLimit\": {\n    \"env\": \"PARSE_SERVER_MAX_LIMIT\",\n    \"help\": \"Max value for limit option on queries, defaults to unlimited\",\n    \"action\": parsers.numberParser(\"maxLimit\")\n  },\n  \"expireInactiveSessions\": {\n    \"env\": \"PARSE_SERVER_EXPIRE_INACTIVE_SESSIONS\",\n    \"help\": \"Sets wether we should expire the inactive sessions, defaults to true\",\n    \"action\": parsers.booleanParser,\n    \"default\": true\n  },\n  \"revokeSessionOnPasswordReset\": {\n    \"env\": \"PARSE_SERVER_REVOKE_SESSION_ON_PASSWORD_RESET\",\n    \"help\": \"When a user changes their password, either through the reset password email or while logged in, all sessions are revoked if this is true. Set to false if you don't want to revoke sessions.\",\n    \"action\": parsers.booleanParser,\n    \"default\": true\n  },\n  \"schemaCacheTTL\": {\n    \"env\": \"PARSE_SERVER_SCHEMA_CACHE_TTL\",\n    \"help\": \"The TTL for caching the schema for optimizing read/write operations. You should put a long TTL when your DB is in production. default to 5000; set 0 to disable.\",\n    \"action\": parsers.numberParser(\"schemaCacheTTL\"),\n    \"default\": 5000\n  },\n  \"cacheTTL\": {\n    \"env\": \"PARSE_SERVER_CACHE_TTL\",\n    \"help\": \"Sets the TTL for the in memory cache (in ms), defaults to 5000 (5 seconds)\",\n    \"action\": parsers.numberParser(\"cacheTTL\"),\n    \"default\": 5000\n  },\n  \"cacheMaxSize\": {\n    \"env\": \"PARSE_SERVER_CACHE_MAX_SIZE\",\n    \"help\": \"Sets the maximum size for the in memory cache, defaults to 10000\",\n    \"action\": parsers.numberParser(\"cacheMaxSize\"),\n    \"default\": 10000\n  },\n  \"enableSingleSchemaCache\": {\n    \"env\": \"PARSE_SERVER_ENABLE_SINGLE_SCHEMA_CACHE\",\n    \"help\": \"Use a single schema cache shared across requests. Reduces number of queries made to _SCHEMA. Defaults to false, i.e. unique schema cache per request.\",\n    \"action\": parsers.booleanParser,\n    \"default\": false\n  },\n  \"enableExpressErrorHandler\": {\n    \"env\": \"PARSE_SERVER_ENABLE_EXPRESS_ERROR_HANDLER\",\n    \"help\": \"Enables the default express error handler for all errors\",\n    \"action\": parsers.booleanParser,\n    \"default\": false\n  },\n  \"objectIdSize\": {\n    \"env\": \"PARSE_SERVER_OBJECT_ID_SIZE\",\n    \"help\": \"Sets the number of characters in generated object id's, default 10\",\n    \"action\": parsers.numberParser(\"objectIdSize\"),\n    \"default\": 10\n  },\n  \"port\": {\n    \"env\": \"PORT\",\n    \"help\": \"The port to run the ParseServer. defaults to 1337.\",\n    \"action\": parsers.numberParser(\"port\"),\n    \"default\": 1337\n  },\n  \"host\": {\n    \"env\": \"PARSE_SERVER_HOST\",\n    \"help\": \"The host to serve ParseServer on. defaults to 0.0.0.0\",\n    \"default\": \"0.0.0.0\"\n  },\n  \"mountPath\": {\n    \"env\": \"PARSE_SERVER_MOUNT_PATH\",\n    \"help\": \"Mount path for the server, defaults to /parse\",\n    \"default\": \"/parse\"\n  },\n  \"cluster\": {\n    \"env\": \"PARSE_SERVER_CLUSTER\",\n    \"help\": \"Run with cluster, optionally set the number of processes default to os.cpus().length\",\n    \"action\": parsers.numberOrBooleanParser\n  },\n  \"middleware\": {\n    \"env\": \"PARSE_SERVER_MIDDLEWARE\",\n    \"help\": \"middleware for express server, can be string or function\"\n  },\n  \"startLiveQueryServer\": {\n    \"env\": \"PARSE_SERVER_START_LIVE_QUERY_SERVER\",\n    \"help\": \"Starts the liveQuery server\",\n    \"action\": parsers.booleanParser\n  },\n  \"liveQueryServerOptions\": {\n    \"env\": \"PARSE_SERVER_LIVE_QUERY_SERVER_OPTIONS\",\n    \"help\": \"Live query server configuration options (will start the liveQuery server)\",\n    \"action\": parsers.objectParser\n  }\n};\nmodule.exports.CustomPagesOptions = {\n  \"invalidLink\": {\n    \"env\": \"PARSE_SERVER_CUSTOM_PAGES_INVALID_LINK\",\n    \"help\": \"invalid link page path\"\n  },\n  \"verifyEmailSuccess\": {\n    \"env\": \"PARSE_SERVER_CUSTOM_PAGES_VERIFY_EMAIL_SUCCESS\",\n    \"help\": \"verify email success page path\"\n  },\n  \"choosePassword\": {\n    \"env\": \"PARSE_SERVER_CUSTOM_PAGES_CHOOSE_PASSWORD\",\n    \"help\": \"choose password page path\"\n  },\n  \"passwordResetSuccess\": {\n    \"env\": \"PARSE_SERVER_CUSTOM_PAGES_PASSWORD_RESET_SUCCESS\",\n    \"help\": \"password reset success page path\"\n  }\n};\nmodule.exports.LiveQueryOptions = {\n  \"classNames\": {\n    \"env\": \"PARSE_SERVER_LIVEQUERY_CLASSNAMES\",\n    \"help\": \"parse-server's LiveQuery classNames\",\n    \"action\": parsers.arrayParser\n  },\n  \"redisURL\": {\n    \"env\": \"PARSE_SERVER_LIVEQUERY_REDIS_URL\",\n    \"help\": \"parse-server's LiveQuery redisURL\"\n  },\n  \"pubSubAdapter\": {\n    \"env\": \"PARSE_SERVER_LIVEQUERY_PUB_SUB_ADAPTER\",\n    \"help\": \"LiveQuery pubsub adapter\",\n    \"action\": parsers.moduleOrObjectParser\n  }\n};\nmodule.exports.LiveQueryServerOptions = {\n  \"appId\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_APP_ID\",\n    \"help\": \"This string should match the appId in use by your Parse Server. If you deploy the LiveQuery server alongside Parse Server, the LiveQuery server will try to use the same appId.\"\n  },\n  \"masterKey\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_MASTER_KEY\",\n    \"help\": \"This string should match the masterKey in use by your Parse Server. If you deploy the LiveQuery server alongside Parse Server, the LiveQuery server will try to use the same masterKey.\"\n  },\n  \"serverURL\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_SERVER_URL\",\n    \"help\": \"This string should match the serverURL in use by your Parse Server. If you deploy the LiveQuery server alongside Parse Server, the LiveQuery server will try to use the same serverURL.\"\n  },\n  \"keyPairs\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_KEY_PAIRS\",\n    \"help\": \"A JSON object that serves as a whitelist of keys. It is used for validating clients when they try to connect to the LiveQuery server. Check the following Security section and our protocol specification for details.\",\n    \"action\": parsers.objectParser\n  },\n  \"websocketTimeout\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_WEBSOCKET_TIMEOUT\",\n    \"help\": \"Number of milliseconds between ping/pong frames. The WebSocket server sends ping/pong frames to the clients to keep the WebSocket alive. This value defines the interval of the ping/pong frame from the server to clients. Defaults to 10 * 1000 ms (10 s).\",\n    \"action\": parsers.numberParser(\"websocketTimeout\")\n  },\n  \"cacheTimeout\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_CACHE_TIMEOUT\",\n    \"help\": \"Number in milliseconds. When clients provide the sessionToken to the LiveQuery server, the LiveQuery server will try to fetch its ParseUser's objectId from parse server and store it in the cache. The value defines the duration of the cache. Check the following Security section and our protocol specification for details. Defaults to 30 * 24 * 60 * 60 * 1000 ms (~30 days).\",\n    \"action\": parsers.numberParser(\"cacheTimeout\")\n  },\n  \"logLevel\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_LOG_LEVEL\",\n    \"help\": \"This string defines the log level of the LiveQuery server. We support VERBOSE, INFO, ERROR, NONE. Defaults to INFO.\"\n  },\n  \"port\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_PORT\",\n    \"help\": \"The port to run the LiveQuery server. Defaults to 1337.\",\n    \"action\": parsers.numberParser(\"port\"),\n    \"default\": 1337\n  },\n  \"redisURL\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_REDIS_URL\",\n    \"help\": \"parse-server's LiveQuery redisURL\"\n  },\n  \"pubSubAdapter\": {\n    \"env\": \"PARSE_LIVE_QUERY_SERVER_PUB_SUB_ADAPTER\",\n    \"help\": \"LiveQuery pubsub adapter\",\n    \"action\": parsers.moduleOrObjectParser\n  }\n};\n"]} \ No newline at end of file diff --git a/lib/Options/index.js b/lib/Options/index.js index 9a390c31f7..30b3ab85bb 100644 --- a/lib/Options/index.js +++ b/lib/Options/index.js @@ -1 +1,2 @@ -"use strict"; \ No newline at end of file +"use strict"; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbXX0= \ No newline at end of file diff --git a/lib/Options/parsers.js b/lib/Options/parsers.js index 4b93c680e9..ce52427c78 100644 --- a/lib/Options/parsers.js +++ b/lib/Options/parsers.js @@ -74,4 +74,5 @@ module.exports = { moduleOrObjectParser, arrayParser, objectParser -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/ParseMessageQueue.js b/lib/ParseMessageQueue.js index 617324204d..23ecf7cb60 100644 --- a/lib/ParseMessageQueue.js +++ b/lib/ParseMessageQueue.js @@ -27,4 +27,5 @@ ParseMessageQueue.createSubscriber = function (config) { return adapter.createSubscriber(config); }; -exports.ParseMessageQueue = ParseMessageQueue; \ No newline at end of file +exports.ParseMessageQueue = ParseMessageQueue; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/ParseServer.js b/lib/ParseServer.js index 218a37f29c..0ad293d7c1 100644 --- a/lib/ParseServer.js +++ b/lib/ParseServer.js @@ -372,4 +372,5 @@ function configureListeners(parseServer) { process.on('SIGINT', handleShutdown); } -exports.default = ParseServer; \ No newline at end of file +exports.default = ParseServer; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ParseServer.js"],"names":["logging","controllers","batch","require","bodyParser","express","middlewares","Parse","path","addParseCloud","ParseServer","constructor","options","injectDefaults","appId","masterKey","cloud","javascriptKey","serverURL","__indexBuildCompletionCallbackForTests","initialize","allControllers","getControllers","loggerController","databaseController","hooksController","config","Config","put","Object","assign","setLogger","dbInitPromise","performInitialization","load","process","env","TESTING","resolve","cwd","app","_app","handleShutdown","adapter","maxUploadSize","api","use","allowCrossDomain","FilesRouter","expressRouter","req","res","json","status","urlencoded","extended","PublicAPIRouter","ImportRouter","limit","allowMethodOverride","handleParseHeaders","appRouter","promiseRouter","handleParseErrors","on","err","code","stderr","write","port","exit","verifyServerUrl","PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS","CoreManager","setRESTController","routers","ClassesRouter","UsersRouter","SessionsRouter","RolesRouter","AnalyticsRouter","InstallationsRouter","FunctionsRouter","SchemasRouter","PushRouter","LogsRouter","IAPValidationRouter","FeaturesRouter","GlobalConfigRouter","PurgeRouter","ExportRouter","HooksRouter","CloudCodeRouter","AudiencesRouter","AggregateRouter","routes","reduce","memo","router","concat","PromiseRouter","mountOnto","start","callback","middleware","mountPath","server","listen","host","startLiveQueryServer","liveQueryServerOptions","liveQueryServer","createLiveQueryServer","configureListeners","expressApp","parseServer","httpServer","createServer","ParseLiveQueryServer","request","replace","error","response","body","JSON","parse","e","statusCode","console","warn","ParseCloud","Cloud","global","keys","defaults","forEach","key","hasOwnProperty","userSensitiveFields","Array","from","Set","masterKeyIps","sockets","socket","socketId","remoteAddress","remotePort","destroyAliveConnections","destroy","stdout","close"],"mappings":"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","file":"ParseServer.js","sourcesContent":["// ParseServer - open-source compatible API Server for Parse apps\n\nvar batch = require('./batch'),\n  bodyParser = require('body-parser'),\n  express = require('express'),\n  middlewares = require('./middlewares'),\n  Parse = require('parse/node').Parse,\n  path = require('path');\n\nimport { ParseServerOptions,\n  LiveQueryServerOptions }      from './Options';\nimport defaults                 from './defaults';\nimport * as logging             from './logger';\nimport Config                   from './Config';\nimport PromiseRouter            from './PromiseRouter';\nimport requiredParameter        from './requiredParameter';\nimport { AnalyticsRouter }      from './Routers/AnalyticsRouter';\nimport { ClassesRouter }        from './Routers/ClassesRouter';\nimport { FeaturesRouter }       from './Routers/FeaturesRouter';\nimport { FilesRouter }          from './Routers/FilesRouter';\nimport { FunctionsRouter }      from './Routers/FunctionsRouter';\nimport { GlobalConfigRouter }   from './Routers/GlobalConfigRouter';\nimport { HooksRouter }          from './Routers/HooksRouter';\nimport { IAPValidationRouter }  from './Routers/IAPValidationRouter';\nimport { InstallationsRouter }  from './Routers/InstallationsRouter';\nimport { LogsRouter }           from './Routers/LogsRouter';\nimport { ParseLiveQueryServer } from './LiveQuery/ParseLiveQueryServer';\nimport { PublicAPIRouter }      from './Routers/PublicAPIRouter';\nimport { PushRouter }           from './Routers/PushRouter';\nimport { CloudCodeRouter }      from './Routers/CloudCodeRouter';\nimport { RolesRouter }          from './Routers/RolesRouter';\nimport { SchemasRouter }        from './Routers/SchemasRouter';\nimport { SessionsRouter }       from './Routers/SessionsRouter';\nimport { UsersRouter }          from './Routers/UsersRouter';\nimport { PurgeRouter }          from './Routers/PurgeRouter';\nimport { AudiencesRouter }      from './Routers/AudiencesRouter';\nimport { AggregateRouter }      from './Routers/AggregateRouter';\nimport { ImportRouter }      from './Routers/ImportRouter';\nimport { ExportRouter }      from './Routers/ExportRouter';\n\nimport { ParseServerRESTController } from './ParseServerRESTController';\nimport * as controllers from './Controllers';\n// Mutate the Parse object to add the Cloud Code handlers\naddParseCloud();\n\n// ParseServer works like a constructor of an express app.\n// The args that we understand are:\n// \"analyticsAdapter\": an adapter class for analytics\n// \"filesAdapter\": a class like GridStoreAdapter providing create, get,\n//                 and delete\n// \"loggerAdapter\": a class like WinstonLoggerAdapter providing info, error,\n//                 and query\n// \"jsonLogs\": log as structured JSON objects\n// \"databaseURI\": a uri like mongodb://localhost:27017/dbname to tell us\n//          what database this Parse API connects to.\n// \"cloud\": relative location to cloud code to require, or a function\n//          that is given an instance of Parse as a parameter.  Use this instance of Parse\n//          to register your cloud code hooks and functions.\n// \"appId\": the application id to host\n// \"masterKey\": the master key for requests to this app\n// \"collectionPrefix\": optional prefix for database collection names\n// \"fileKey\": optional key from Parse dashboard for supporting older files\n//            hosted by Parse\n// \"clientKey\": optional key from Parse dashboard\n// \"dotNetKey\": optional key from Parse dashboard\n// \"restAPIKey\": optional key from Parse dashboard\n// \"webhookKey\": optional key from Parse dashboard\n// \"javascriptKey\": optional key from Parse dashboard\n// \"push\": optional key from configure push\n// \"sessionLength\": optional length in seconds for how long Sessions should be valid for\n// \"maxLimit\": optional upper bound for what can be specified for the 'limit' parameter on queries\n\nclass ParseServer {\n\n  constructor(options: ParseServerOptions) {\n    injectDefaults(options);\n    const {\n      appId = requiredParameter('You must provide an appId!'),\n      masterKey = requiredParameter('You must provide a masterKey!'),\n      cloud,\n      javascriptKey,\n      serverURL = requiredParameter('You must provide a serverURL!'),\n      __indexBuildCompletionCallbackForTests = () => {},\n    } = options;\n    // Initialize the node client SDK automatically\n    Parse.initialize(appId, javascriptKey || 'unused', masterKey);\n    Parse.serverURL = serverURL;\n\n    const allControllers = controllers.getControllers(options);\n\n    const {\n      loggerController,\n      databaseController,\n      hooksController,\n    } = allControllers;\n    this.config = Config.put(Object.assign({}, options, allControllers));\n\n    logging.setLogger(loggerController);\n    const dbInitPromise = databaseController.performInitialization();\n    hooksController.load();\n\n    // Note: Tests will start to fail if any validation happens after this is called.\n    if (process.env.TESTING) {\n      __indexBuildCompletionCallbackForTests(dbInitPromise);\n    }\n\n    if (cloud) {\n      addParseCloud();\n      if (typeof cloud === 'function') {\n        cloud(Parse)\n      } else if (typeof cloud === 'string') {\n        require(path.resolve(process.cwd(), cloud));\n      } else {\n        throw \"argument 'cloud' must either be a string or a function\";\n      }\n    }\n  }\n\n  get app() {\n    if (!this._app) {\n      this._app = ParseServer.app(this.config);\n    }\n    return this._app;\n  }\n\n  handleShutdown() {\n    const { adapter } = this.config.databaseController;\n    if (adapter && typeof adapter.handleShutdown === 'function') {\n      adapter.handleShutdown();\n    }\n  }\n\n  static app({maxUploadSize = '20mb', appId}) {\n    // This app serves the Parse API directly.\n    // It's the equivalent of https://api.parse.com/1 in the hosted Parse API.\n    var api = express();\n    //api.use(\"/apps\", express.static(__dirname + \"/public\"));\n    // File handling needs to be before default middlewares are applied\n    api.use('/', middlewares.allowCrossDomain, new FilesRouter().expressRouter({\n      maxUploadSize: maxUploadSize\n    }));\n\n    api.use('/health', (function(req, res) {\n      res.json({\n        status: 'ok'\n      });\n    }));\n\n    api.use('/', bodyParser.urlencoded({extended: false}), new PublicAPIRouter().expressRouter());\n\n    api.use('/', middlewares.allowCrossDomain, new ImportRouter().expressRouter());\n    api.use(bodyParser.json({ 'type': '*/*' , limit: maxUploadSize }));\n    api.use(middlewares.allowCrossDomain);\n    api.use(middlewares.allowMethodOverride);\n    api.use(middlewares.handleParseHeaders);\n\n    const appRouter = ParseServer.promiseRouter({ appId });\n    api.use(appRouter.expressRouter());\n\n    api.use(middlewares.handleParseErrors);\n\n    // run the following when not testing\n    if (!process.env.TESTING) {\n      //This causes tests to spew some useless warnings, so disable in test\n      /* istanbul ignore next */\n      process.on('uncaughtException', (err) => {\n        if (err.code === \"EADDRINUSE\") { // user-friendly message for this common error\n          process.stderr.write(`Unable to listen on port ${err.port}. The port is already in use.`);\n          process.exit(0);\n        } else {\n          throw err;\n        }\n      });\n      // verify the server url after a 'mount' event is received\n      /* istanbul ignore next */\n      api.on('mount', function() {\n        ParseServer.verifyServerUrl();\n      });\n    }\n    if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1') {\n      Parse.CoreManager.setRESTController(ParseServerRESTController(appId, appRouter));\n    }\n    return api;\n  }\n\n  static promiseRouter({appId}) {\n    const routers = [\n      new ClassesRouter(),\n      new UsersRouter(),\n      new SessionsRouter(),\n      new RolesRouter(),\n      new AnalyticsRouter(),\n      new InstallationsRouter(),\n      new FunctionsRouter(),\n      new SchemasRouter(),\n      new PushRouter(),\n      new LogsRouter(),\n      new IAPValidationRouter(),\n      new FeaturesRouter(),\n      new GlobalConfigRouter(),\n      new PurgeRouter(),\n      new ExportRouter(),\n      new HooksRouter(),\n      new CloudCodeRouter(),\n      new AudiencesRouter(),\n      new AggregateRouter()\n    ];\n\n    const routes = routers.reduce((memo, router) => {\n      return memo.concat(router.routes);\n    }, []);\n\n    const appRouter = new PromiseRouter(routes, appId);\n\n    batch.mountOnto(appRouter);\n    return appRouter;\n  }\n\n  start(options: ParseServerOptions, callback: ?()=>void) {\n    const app = express();\n    if (options.middleware) {\n      let middleware;\n      if (typeof options.middleware == 'string') {\n        middleware = require(path.resolve(process.cwd(), options.middleware));\n      } else {\n        middleware = options.middleware; // use as-is let express fail\n      }\n      app.use(middleware);\n    }\n\n    app.use(options.mountPath, this.app);\n    const server = app.listen(options.port, options.host, callback);\n    this.server = server;\n\n    if (options.startLiveQueryServer || options.liveQueryServerOptions) {\n      this.liveQueryServer = ParseServer.createLiveQueryServer(server, options.liveQueryServerOptions);\n    }\n    /* istanbul ignore next */\n    if (!process.env.TESTING) {\n      configureListeners(this);\n    }\n    this.expressApp = app;\n    return this;\n  }\n\n  static start(options: ParseServerOptions, callback: ?()=>void) {\n    const parseServer = new ParseServer(options);\n    return parseServer.start(options, callback);\n  }\n\n  static createLiveQueryServer(httpServer, config: LiveQueryServerOptions) {\n    if (!httpServer || (config && config.port)) {\n      var app = express();\n      httpServer = require('http').createServer(app);\n      httpServer.listen(config.port);\n    }\n    return new ParseLiveQueryServer(httpServer, config);\n  }\n\n  static verifyServerUrl(callback) {\n    // perform a health check on the serverURL value\n    if(Parse.serverURL) {\n      const request = require('request');\n      request(Parse.serverURL.replace(/\\/$/, \"\") + \"/health\", function (error, response, body) {\n        let json;\n        try {\n          json = JSON.parse(body);\n        } catch(e) {\n          json = null;\n        }\n        if (error || response.statusCode !== 200 || !json || json && json.status !== 'ok') {\n          /* eslint-disable no-console */\n          console.warn(`\\nWARNING, Unable to connect to '${Parse.serverURL}'.` +\n            ` Cloud code and push notifications may be unavailable!\\n`);\n          /* eslint-enable no-console */\n          if(callback) {\n            callback(false);\n          }\n        } else {\n          if(callback) {\n            callback(true);\n          }\n        }\n      });\n    }\n  }\n}\n\nfunction addParseCloud() {\n  const ParseCloud = require(\"./cloud-code/Parse.Cloud\");\n  Object.assign(Parse.Cloud, ParseCloud);\n  global.Parse = Parse;\n}\n\nfunction injectDefaults(options: ParseServerOptions) {\n  Object.keys(defaults).forEach((key) => {\n    if (!options.hasOwnProperty(key)) {\n      options[key] = defaults[key];\n    }\n  });\n\n  if (!options.hasOwnProperty('serverURL')) {\n    options.serverURL = `http://localhost:${options.port}${options.mountPath}`;\n  }\n\n  options.userSensitiveFields = Array.from(new Set(options.userSensitiveFields.concat(\n    defaults.userSensitiveFields,\n    options.userSensitiveFields\n  )));\n\n  options.masterKeyIps = Array.from(new Set(options.masterKeyIps.concat(\n    defaults.masterKeyIps,\n    options.masterKeyIps\n  )));\n}\n\n// Those can't be tested as it requires a subprocess\n/* istanbul ignore next */\nfunction configureListeners(parseServer) {\n  const server = parseServer.server;\n  const sockets = {};\n  /* Currently, express doesn't shut down immediately after receiving SIGINT/SIGTERM if it has client connections that haven't timed out. (This is a known issue with node - https://github.com/nodejs/node/issues/2642)\n    This function, along with `destroyAliveConnections()`, intend to fix this behavior such that parse server will close all open connections and initiate the shutdown process as soon as it receives a SIGINT/SIGTERM signal. */\n  server.on('connection', (socket) => {\n    const socketId = socket.remoteAddress + ':' + socket.remotePort;\n    sockets[socketId] = socket;\n    socket.on('close', () => {\n      delete sockets[socketId];\n    });\n  });\n\n  const destroyAliveConnections = function() {\n    for (const socketId in sockets) {\n      try {\n        sockets[socketId].destroy();\n      } catch (e) { /* */ }\n    }\n  }\n\n  const handleShutdown = function() {\n    process.stdout.write('Termination signal received. Shutting down.');\n    destroyAliveConnections();\n    server.close();\n    parseServer.handleShutdown();\n  };\n  process.on('SIGTERM', handleShutdown);\n  process.on('SIGINT', handleShutdown);\n}\n\nexport default ParseServer;\n"]} \ No newline at end of file diff --git a/lib/ParseServerRESTController.js b/lib/ParseServerRESTController.js index 2ae687a32a..227a3d3ff0 100644 --- a/lib/ParseServerRESTController.js +++ b/lib/ParseServerRESTController.js @@ -100,4 +100,5 @@ function ParseServerRESTController(applicationId, router) { } exports.default = ParseServerRESTController; -exports.ParseServerRESTController = ParseServerRESTController; \ No newline at end of file +exports.ParseServerRESTController = ParseServerRESTController; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ParseServerRESTController.js"],"names":["Config","require","Auth","RESTController","URL","Parse","getSessionToken","options","sessionToken","Promise","as","getAuth","config","installationId","useMasterKey","isMaster","then","getAuthForSessionToken","ParseServerRESTController","applicationId","router","handleRequest","method","path","data","args","arguments","get","serverURL","parse","indexOf","slice","length","promises","requests","map","request","body","response","success","error","code","message","all","query","resolve","reject","auth","info","tryRouteRequest","status","err","Error","INVALID_JSON","apply","ajax"],"mappings":"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","file":"ParseServerRESTController.js","sourcesContent":["const Config = require('./Config');\nconst Auth = require('./Auth');\nconst RESTController = require('parse/lib/node/RESTController');\nconst URL = require('url');\nconst Parse = require('parse/node');\n\nfunction getSessionToken(options) {\n  if (options && typeof options.sessionToken === 'string') {\n    return Parse.Promise.as(options.sessionToken);\n  }\n  return Parse.Promise.as(null);\n}\n\nfunction getAuth(options = {}, config) {\n  const installationId = options.installationId || 'cloud';\n  if (options.useMasterKey) {\n    return Parse.Promise.as(new Auth.Auth({config, isMaster: true, installationId }));\n  }\n  return getSessionToken(options).then((sessionToken) => {\n    if (sessionToken) {\n      options.sessionToken = sessionToken;\n      return Auth.getAuthForSessionToken({\n        config,\n        sessionToken: sessionToken,\n        installationId\n      });\n    } else {\n      return Parse.Promise.as(new Auth.Auth({ config, installationId }));\n    }\n  })\n}\n\nfunction ParseServerRESTController(applicationId, router) {\n  function handleRequest(method, path, data = {}, options = {}) {\n    // Store the arguments, for later use if internal fails\n    const args = arguments;\n\n    const config = Config.get(applicationId);\n    const serverURL = URL.parse(config.serverURL);\n    if (path.indexOf(serverURL.path) === 0) {\n      path = path.slice(serverURL.path.length, path.length);\n    }\n\n    if (path[0] !== \"/\") {\n      path = \"/\" + path;\n    }\n\n    if (path === '/batch') {\n      const promises = data.requests.map((request) => {\n        return handleRequest(request.method, request.path, request.body, options).then((response) => {\n          return Parse.Promise.as({success: response});\n        }, (error) => {\n          return Parse.Promise.as({error: {code: error.code, error: error.message}});\n        });\n      });\n      return Parse.Promise.all(promises);\n    }\n\n    let query;\n    if (method === 'GET') {\n      query = data;\n    }\n\n    return new Parse.Promise((resolve, reject) => {\n      getAuth(options, config).then((auth) => {\n        const request = {\n          body: data,\n          config,\n          auth,\n          info: {\n            applicationId: applicationId,\n            sessionToken: options.sessionToken\n          },\n          query\n        };\n        return Promise.resolve().then(() => {\n          return router.tryRouteRequest(method, path, request);\n        }).then((response) => {\n          resolve(response.response, response.status, response);\n        }, (err) => {\n          if (err instanceof Parse.Error &&\n              err.code == Parse.Error.INVALID_JSON &&\n              err.message == `cannot route ${method} ${path}`) {\n            RESTController.request.apply(null, args).then(resolve, reject);\n          } else {\n            reject(err);\n          }\n        });\n      }, reject);\n    });\n  }\n\n  return  {\n    request: handleRequest,\n    ajax: RESTController.ajax\n  };\n}\n\nexport default ParseServerRESTController;\nexport { ParseServerRESTController };\n"]} \ No newline at end of file diff --git a/lib/PromiseRouter.js b/lib/PromiseRouter.js index 120ec91d54..e5eaf0b97c 100644 --- a/lib/PromiseRouter.js +++ b/lib/PromiseRouter.js @@ -215,4 +215,5 @@ function maskSensitiveUrl(req) { maskUrl = _logger2.default.maskSensitiveUrl(maskUrl); } return maskUrl; -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/PromiseRouter.js"],"names":["Layer","require","validateParameter","key","value","match","PromiseRouter","constructor","routes","appId","mountRoutes","merge","router","route","push","method","path","handlers","handler","length","req","reduce","promise","then","Promise","resolve","layer","params","Object","keys","forEach","mountOnto","expressApp","toLowerCase","makeExpressHandler","call","expressRouter","express","Router","tryRouteRequest","request","Parse","Error","INVALID_JSON","reject","promiseHandler","res","next","url","maskSensitiveUrl","body","assign","headers","log","logRequest","result","response","location","text","error","logResponse","status","send","set","header","json","e","maskUrl","originalUrl","toString","shouldMaskUrl","includes"],"mappings":"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","file":"PromiseRouter.js","sourcesContent":["// A router that is based on promises rather than req/res/next.\n// This is intended to replace the use of express.Router to handle\n// subsections of the API surface.\n// This will make it easier to have methods like 'batch' that\n// themselves use our routing information, without disturbing express\n// components that external developers may be modifying.\n\nimport Parse     from 'parse/node';\nimport express   from 'express';\nimport log       from './logger';\nimport {inspect} from 'util';\nconst Layer = require('express/lib/router/layer');\n\nfunction validateParameter(key, value) {\n  if (key == 'className') {\n    if (value.match(/_?[A-Za-z][A-Za-z_0-9]*/)) {\n      return value;\n    }\n  } else if (key == 'objectId') {\n    if (value.match(/[A-Za-z0-9]+/)) {\n      return value;\n    }\n  } else {\n    return value;\n  }\n}\n\n\nexport default class PromiseRouter {\n  // Each entry should be an object with:\n  // path: the path to route, in express format\n  // method: the HTTP method that this route handles.\n  //   Must be one of: POST, GET, PUT, DELETE\n  // handler: a function that takes request, and returns a promise.\n  //   Successful handlers should resolve to an object with fields:\n  //     status: optional. the http status code. defaults to 200\n  //     response: a json object with the content of the response\n  //     location: optional. a location header\n  constructor(routes = [], appId) {\n    this.routes = routes;\n    this.appId = appId;\n    this.mountRoutes();\n  }\n\n  // Leave the opportunity to\n  // subclasses to mount their routes by overriding\n  mountRoutes() {}\n\n  // Merge the routes into this one\n  merge(router) {\n    for (var route of router.routes) {\n      this.routes.push(route);\n    }\n  }\n\n  route(method, path, ...handlers) {\n    switch(method) {\n    case 'POST':\n    case 'GET':\n    case 'PUT':\n    case 'DELETE':\n      break;\n    default:\n      throw 'cannot route method: ' + method;\n    }\n\n    let handler = handlers[0];\n\n    if (handlers.length > 1) {\n      handler = function(req) {\n        return handlers.reduce((promise, handler) => {\n          return promise.then(() => {\n            return handler(req);\n          });\n        }, Promise.resolve());\n      }\n    }\n\n    this.routes.push({\n      path: path,\n      method: method,\n      handler: handler,\n      layer: new Layer(path, null, handler)\n    });\n  }\n\n  // Returns an object with:\n  //   handler: the handler that should deal with this request\n  //   params: any :-params that got parsed from the path\n  // Returns undefined if there is no match.\n  match(method, path) {\n    for (var route of this.routes) {\n      if (route.method != method) {\n        continue;\n      }\n      const layer = route.layer || new Layer(route.path, null, route.handler);\n      const match = layer.match(path);\n      if (match) {\n        const params = layer.params;\n        Object.keys(params).forEach((key) => {\n          params[key] = validateParameter(key, params[key]);\n        });\n        return {params: params, handler: route.handler};\n      }\n    }\n  }\n\n  // Mount the routes on this router onto an express app (or express router)\n  mountOnto(expressApp) {\n    this.routes.forEach((route) => {\n      const method = route.method.toLowerCase();\n      const handler = makeExpressHandler(this.appId, route.handler);\n      expressApp[method].call(expressApp, route.path, handler);\n    });\n    return expressApp;\n  }\n\n  expressRouter() {\n    return this.mountOnto(express.Router());\n  }\n\n  tryRouteRequest(method, path, request) {\n    var match = this.match(method, path);\n    if (!match) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_JSON,\n        'cannot route ' + method + ' ' + path);\n    }\n    request.params = match.params;\n    return new Promise((resolve, reject) => {\n      match.handler(request).then(resolve, reject);\n    });\n  }\n}\n\n// A helper function to make an express handler out of a a promise\n// handler.\n// Express handlers should never throw; if a promise handler throws we\n// just treat it like it resolved to an error.\nfunction makeExpressHandler(appId, promiseHandler) {\n  return function(req, res, next) {\n    try {\n      const url = maskSensitiveUrl(req);\n      const body = Object.assign({}, req.body);\n      const method = req.method;\n      const headers = req.headers;\n      log.logRequest({\n        method,\n        url,\n        headers,\n        body\n      });\n      promiseHandler(req).then((result) => {\n        if (!result.response && !result.location && !result.text) {\n          log.error('the handler did not include a \"response\" or a \"location\" field');\n          throw 'control should not get here';\n        }\n\n        log.logResponse({ method, url, result });\n\n        var status = result.status || 200;\n        res.status(status);\n\n        if (result.text) {\n          res.send(result.text);\n          return;\n        }\n\n        if (result.location) {\n          res.set('Location', result.location);\n          // Override the default expressjs response\n          // as it double encodes %encoded chars in URL\n          if (!result.response) {\n            res.send('Found. Redirecting to ' + result.location);\n            return;\n          }\n        }\n        if (result.headers) {\n          Object.keys(result.headers).forEach((header) => {\n            res.set(header, result.headers[header]);\n          })\n        }\n        res.json(result.response);\n      }, (e) => {\n        log.error(`Error generating response. ${inspect(e)}`, {error: e});\n        next(e);\n      });\n    } catch (e) {\n      log.error(`Error handling request: ${inspect(e)}`, {error: e});\n      next(e);\n    }\n  }\n}\n\n\nfunction maskSensitiveUrl(req) {\n  let maskUrl = req.originalUrl.toString();\n  const shouldMaskUrl = req.method === 'GET' && req.originalUrl.includes('/login')\n                      && !req.originalUrl.includes('classes');\n  if (shouldMaskUrl) {\n    maskUrl = log.maskSensitiveUrl(maskUrl);\n  }\n  return maskUrl;\n}\n"]} \ No newline at end of file diff --git a/lib/Push/PushQueue.js b/lib/Push/PushQueue.js index 7771600888..17a550fea0 100644 --- a/lib/Push/PushQueue.js +++ b/lib/Push/PushQueue.js @@ -69,4 +69,5 @@ class PushQueue { }); } } -exports.PushQueue = PushQueue; \ No newline at end of file +exports.PushQueue = PushQueue; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Push/PushWorker.js b/lib/Push/PushWorker.js index 3777a451c9..b9046fdcb5 100644 --- a/lib/Push/PushWorker.js +++ b/lib/Push/PushWorker.js @@ -70,12 +70,6 @@ class PushWorker { } } - unsubscribe() { - if (this.subscriber) { - this.subscriber.unsubscribe(this.channel); - } - } - run({ body, query, pushStatus, applicationId, UTCOffset }) { const config = _Config2.default.get(applicationId); const auth = (0, _Auth.master)(config); @@ -87,8 +81,6 @@ class PushWorker { return pushStatus.trackSent(results); } return this.sendToAdapter(body, results, pushStatus, config, UTCOffset); - }, err => { - throw err; }); } @@ -147,4 +139,5 @@ class PushWorker { } exports.PushWorker = PushWorker; -exports.default = PushWorker; \ No newline at end of file +exports.default = PushWorker; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Push/PushWorker.js"],"names":["utils","groupByBadge","installations","reduce","map","installation","badge","push","PushWorker","constructor","pushAdapter","subscriberConfig","AdaptableController","validateAdapter","PushAdapter","adapter","channel","PushQueue","defaultPushChannel","subscriber","ParseMessageQueue","createSubscriber","subscribe","on","messageStr","workItem","JSON","parse","getAndRun","run","body","query","pushStatus","applicationId","UTCOffset","config","Config","get","auth","where","applyDeviceTokenExists","objectId","rest","find","then","results","length","trackSent","sendToAdapter","locales","getLocalesFromPush","bodiesPerLocales","grouppedInstallations","groupByLocaleIdentifier","promises","Object","keys","locale","Promise","all","isPushIncrementing","logger","verbose","send","undefined","badgeInstallationsMap","payload","data","parseInt","_this","gotItem","resolve"],"mappings":";;;;;;;AAEA;;;;AACA;;;;AACA;;AACA;;;;AACA;;AACA;;;;AACA;;AACA;;IAAYA,K;;AACZ;;AACA;;AACA;;;;;;;;AAEA,SAASC,YAAT,CAAsBC,aAAtB,EAAqC;AACnC,SAAOA,cAAcC,MAAd,CAAqB,CAACC,GAAD,EAAMC,YAAN,KAAuB;AACjD,UAAMC,QAAQD,aAAaC,KAAb,GAAqB,EAAnC;AACAF,QAAIE,KAAJ,IAAaF,IAAIE,KAAJ,KAAc,EAA3B;AACAF,QAAIE,KAAJ,EAAWC,IAAX,CAAgBF,YAAhB;AACA,WAAOD,GAAP;AACD,GALM,EAKJ,EALI,CAAP;AAMD;AApBD;AAsBO,MAAMI,UAAN,CAAiB;;AAKtBC,cAAYC,WAAZ,EAAsCC,mBAAwB,EAA9D,EAAkE;AAChEC,kCAAoBC,eAApB,CAAoCH,WAApC,EAAiD,IAAjD,EAAuDI,wBAAvD;AACA,SAAKC,OAAL,GAAeL,WAAf;;AAEA,SAAKM,OAAL,GAAeL,iBAAiBK,OAAjB,IAA4BC,qBAAUC,kBAAV,EAA3C;AACA,SAAKC,UAAL,GAAkBC,qCAAkBC,gBAAlB,CAAmCV,gBAAnC,CAAlB;AACA,QAAI,KAAKQ,UAAT,EAAqB;AACnB,YAAMA,aAAa,KAAKA,UAAxB;AACAA,iBAAWG,SAAX,CAAqB,KAAKN,OAA1B;AACAG,iBAAWI,EAAX,CAAc,SAAd,EAAyB,CAACP,OAAD,EAAUQ,UAAV,KAAyB;AAChD,cAAMC,WAAWC,KAAKC,KAAL,CAAWH,UAAX,CAAjB;AACA,aAAKI,SAAL,CAAeH,QAAf;AACD,OAHD;AAID;AACF;;AAEDI,MAAI,EAAEC,IAAF,EAAQC,KAAR,EAAeC,UAAf,EAA2BC,aAA3B,EAA0CC,SAA1C,EAAJ,EAA8E;AAC5E,UAAMC,SAASC,iBAAOC,GAAP,CAAWJ,aAAX,CAAf;AACA,UAAMK,OAAO,kBAAOH,MAAP,CAAb;AACA,UAAMI,QAAQvC,MAAMwC,sBAAN,CAA6BT,MAAMQ,KAAnC,CAAd;AACA,WAAOR,MAAMQ,KAAb;AACAP,iBAAa,sCAAkBG,MAAlB,EAA0BH,WAAWS,QAArC,CAAb;AACA,WAAOC,eAAKC,IAAL,CAAUR,MAAV,EAAkBG,IAAlB,EAAwB,eAAxB,EAAyCC,KAAzC,EAAgDR,KAAhD,EAAuDa,IAAvD,CAA4D,CAAC,EAACC,OAAD,EAAD,KAAe;AAChF,UAAIA,QAAQC,MAAR,IAAkB,CAAtB,EAAyB;AACvB,eAAOd,WAAWe,SAAX,CAAqBF,OAArB,CAAP;AACD;AACD,aAAO,KAAKG,aAAL,CAAmBlB,IAAnB,EAAyBe,OAAzB,EAAkCb,UAAlC,EAA8CG,MAA9C,EAAsDD,SAAtD,CAAP;AACD,KALM,CAAP;AAMD;;AAEDc,gBAAclB,IAAd,EAAyB5B,aAAzB,EAA6C8B,UAA7C,EAA8DG,MAA9D,EAA8ED,SAA9E,EAA4G;AAC1G;AACA,UAAMe,UAAUjD,MAAMkD,kBAAN,CAAyBpB,IAAzB,CAAhB;AACA,QAAImB,QAAQH,MAAR,GAAiB,CAArB,EAAwB;AACtB;AACA,YAAMK,mBAAmBnD,MAAMmD,gBAAN,CAAuBrB,IAAvB,EAA6BmB,OAA7B,CAAzB;;AAEA;AACA,YAAMG,wBAAwBpD,MAAMqD,uBAAN,CAA8BnD,aAA9B,EAA6C+C,OAA7C,CAA9B;AACA,YAAMK,WAAWC,OAAOC,IAAP,CAAYJ,qBAAZ,EAAmChD,GAAnC,CAAwCqD,MAAD,IAAY;AAClE,cAAMvD,gBAAgBkD,sBAAsBK,MAAtB,CAAtB;AACA,cAAM3B,OAAOqB,iBAAiBM,MAAjB,CAAb;AACA,eAAO,KAAKT,aAAL,CAAmBlB,IAAnB,EAAyB5B,aAAzB,EAAwC8B,UAAxC,EAAoDG,MAApD,EAA4DD,SAA5D,CAAP;AACD,OAJgB,CAAjB;AAKA,aAAOwB,QAAQC,GAAR,CAAYL,QAAZ,CAAP;AACD;;AAED,QAAI,CAACtD,MAAM4D,kBAAN,CAAyB9B,IAAzB,CAAL,EAAqC;AACnC+B,uBAAOC,OAAP,CAAgB,mBAAkB5D,cAAc4C,MAAO,EAAvD;AACA,aAAO,KAAK/B,OAAL,CAAagD,IAAb,CAAkBjC,IAAlB,EAAwB5B,aAAxB,EAAuC8B,WAAWS,QAAlD,EAA4DG,IAA5D,CAAkEC,OAAD,IAAa;AACnF,eAAOb,WAAWe,SAAX,CAAqBF,OAArB,EAA8BX,SAA9B,EAAyC8B,SAAzC,EAAoD9D,cAAc4C,MAAd,GAAuBD,QAAQC,MAAnF,EACJF,IADI,CACC,MAAMC,OADP,CAAP;AAED,OAHM,CAAP;AAID;;AAED;AACA,UAAMoB,wBAAwBhE,aAAaC,aAAb,CAA9B;;AAEA;AACA,UAAMoD,WAAWC,OAAOC,IAAP,CAAYS,qBAAZ,EAAmC7D,GAAnC,CAAwCE,KAAD,IAAW;AACjE,YAAM4D,UAAU,wBAASpC,IAAT,CAAhB;AACAoC,cAAQC,IAAR,CAAa7D,KAAb,GAAqB8D,SAAS9D,KAAT,CAArB;AACA,YAAMJ,gBAAgB+D,sBAAsB3D,KAAtB,CAAtB;AACA,aAAO,KAAK0C,aAAL,CAAmBkB,OAAnB,EAA4BhE,aAA5B,EAA2C8B,UAA3C,EAAuDG,MAAvD,EAA+DD,SAA/D,CAAP;AACD,KALgB,CAAjB;AAMA,WAAOwB,QAAQC,GAAR,CAAYL,QAAZ,CAAP;AACD;;AAED1B,YAAUH,QAAV,EAAuC;AACrC,QAAI4C,QAAQ,IAAZ;AACA,QAAI,CAACA,MAAMlD,UAAN,CAAiBU,GAAtB,EAA2B;AACzB,aAAOwC,MAAMxC,GAAN,CAAUJ,QAAV,CAAP;AACD;AACD,WAAO4C,MAAMlD,UAAN,CAAiBU,GAAjB,CAAqBJ,QAArB,EAA+BmB,IAA/B,CAAoC,UAAU0B,OAAV,EAAmB;AAC5D,UAAIA,OAAJ,EAAa;AACX,eAAOD,MAAMxC,GAAN,CAAUyC,OAAV,EACJ1B,IADI,CACC,YAAY;AAChB,iBAAOyB,MAAMzC,SAAN,CAAgB0C,OAAhB,CAAP;AACD,SAHI,CAAP;AAID,OALD,MAKO;AACL,eAAOZ,QAAQa,OAAR,EAAP;AACD;AACF,KATM,CAAP;AAUD;AAxFqB;;QAAX/D,U,GAAAA,U;kBA2FEA,U","file":"PushWorker.js","sourcesContent":["// @flow\n// @flow-disable-next\nimport deepcopy               from 'deepcopy';\nimport AdaptableController    from '../Controllers/AdaptableController';\nimport { master }             from '../Auth';\nimport Config                 from '../Config';\nimport { PushAdapter }        from '../Adapters/Push/PushAdapter';\nimport rest                   from '../rest';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport * as utils             from './utils';\nimport { ParseMessageQueue }  from '../ParseMessageQueue';\nimport { PushQueue }          from './PushQueue';\nimport logger                 from '../logger';\n\nfunction groupByBadge(installations) {\n  return installations.reduce((map, installation) => {\n    const badge = installation.badge + '';\n    map[badge] = map[badge] || [];\n    map[badge].push(installation);\n    return map;\n  }, {});\n}\n\nexport class PushWorker {\n  subscriber: any;\n  adapter: any;\n  channel: string;\n\n  constructor(pushAdapter: PushAdapter, subscriberConfig: any = {}) {\n    AdaptableController.validateAdapter(pushAdapter, this, PushAdapter);\n    this.adapter = pushAdapter;\n\n    this.channel = subscriberConfig.channel || PushQueue.defaultPushChannel();\n    this.subscriber = ParseMessageQueue.createSubscriber(subscriberConfig);\n    if (this.subscriber) {\n      const subscriber = this.subscriber;\n      subscriber.subscribe(this.channel);\n      subscriber.on('message', (channel, messageStr) => {\n        const workItem = JSON.parse(messageStr);\n        this.getAndRun(workItem);\n      });\n    }\n  }\n\n  run({ body, query, pushStatus, applicationId, UTCOffset }: any): Promise<any> {\n    const config = Config.get(applicationId);\n    const auth = master(config);\n    const where = utils.applyDeviceTokenExists(query.where);\n    delete query.where;\n    pushStatus = pushStatusHandler(config, pushStatus.objectId);\n    return rest.find(config, auth, '_Installation', where, query).then(({results}) => {\n      if (results.length == 0) {\n        return pushStatus.trackSent(results);\n      }\n      return this.sendToAdapter(body, results, pushStatus, config, UTCOffset);\n    });\n  }\n\n  sendToAdapter(body: any, installations: any, pushStatus: any, config: Config, UTCOffset: any): Promise<any> {\n    // Check if we have locales in the push body\n    const locales = utils.getLocalesFromPush(body);\n    if (locales.length > 0) {\n      // Get all tranformed bodies for each locale\n      const bodiesPerLocales = utils.bodiesPerLocales(body, locales);\n\n      // Group installations on the specified locales (en, fr, default etc...)\n      const grouppedInstallations = utils.groupByLocaleIdentifier(installations, locales);\n      const promises = Object.keys(grouppedInstallations).map((locale) => {\n        const installations = grouppedInstallations[locale];\n        const body = bodiesPerLocales[locale];\n        return this.sendToAdapter(body, installations, pushStatus, config, UTCOffset);\n      });\n      return Promise.all(promises);\n    }\n\n    if (!utils.isPushIncrementing(body)) {\n      logger.verbose(`Sending push to ${installations.length}`);\n      return this.adapter.send(body, installations, pushStatus.objectId).then((results) => {\n        return pushStatus.trackSent(results, UTCOffset, undefined, installations.length - results.length)\n          .then(() => results);\n      });\n    }\n\n    // Collect the badges to reduce the # of calls\n    const badgeInstallationsMap = groupByBadge(installations);\n\n    // Map the on the badges count and return the send result\n    const promises = Object.keys(badgeInstallationsMap).map((badge) => {\n      const payload = deepcopy(body);\n      payload.data.badge = parseInt(badge);\n      const installations = badgeInstallationsMap[badge];\n      return this.sendToAdapter(payload, installations, pushStatus, config, UTCOffset);\n    });\n    return Promise.all(promises);\n  }\n\n  getAndRun(workItem: any): Promise<any> {\n    var _this = this;\n    if (!_this.subscriber.run) {\n      return _this.run(workItem);\n    }\n    return _this.subscriber.run(workItem).then(function (gotItem) {\n      if (gotItem) {\n        return _this.run(gotItem)\n          .then(function () {\n            return _this.getAndRun(gotItem)\n          })\n      } else {\n        return Promise.resolve();\n      }\n    });\n  }\n}\n\nexport default PushWorker;\n"]} \ No newline at end of file diff --git a/lib/Push/utils.js b/lib/Push/utils.js index a526977766..3fbc8f7581 100644 --- a/lib/Push/utils.js +++ b/lib/Push/utils.js @@ -23,7 +23,16 @@ var _deepcopy2 = _interopRequireDefault(_deepcopy); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function isPushIncrementing(body) { - return body.data && body.data.badge && typeof body.data.badge == 'string' && body.data.badge.toLowerCase() == "increment"; + if (!body.data || !body.data.badge) { + return false; + } + + const badge = body.data.badge; + if (typeof badge == 'string' && badge.toLowerCase() == "increment") { + return true; + } + + return typeof badge == 'object' && typeof badge.__op == 'string' && badge.__op.toLowerCase() == "increment" && Number(badge.amount); } const localizableKeys = ['alert', 'title']; @@ -130,4 +139,5 @@ function applyDeviceTokenExists(where) { where['deviceToken'] = { '$exists': true }; } return where; -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Push/utils.js"],"names":["isPushIncrementing","getLocalesFromPush","transformPushBodyForLocale","stripLocalesFromBody","bodiesPerLocales","groupByLocaleIdentifier","validatePushType","applyDeviceTokenExists","body","data","badge","toLowerCase","__op","Number","amount","localizableKeys","Set","Object","keys","reduce","memo","key","forEach","localizableKey","indexOf","push","slice","length","locale","localeValue","locales","result","default","installations","map","installation","added","localeIdentifier","where","validPushTypes","deviceTypeField","deviceType","deviceTypes","Array","isArray","concat","i","Parse","Error","PUSH_MISCONFIGURED","hasOwnProperty"],"mappings":"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","file":"utils.js","sourcesContent":["import Parse    from 'parse/node';\nimport deepcopy from 'deepcopy';\n\nexport function isPushIncrementing(body) {\n  if (!body.data || !body.data.badge) {\n    return false;\n  }\n\n  const badge = body.data.badge;\n  if (typeof badge == 'string' && badge.toLowerCase() == \"increment\") {\n    return true;\n  }\n\n  return typeof badge == 'object' && typeof badge.__op == 'string' &&\n         badge.__op.toLowerCase() == \"increment\" && Number(badge.amount);\n}\n\nconst localizableKeys = ['alert', 'title'];\n\nexport function getLocalesFromPush(body) {\n  const data = body.data;\n  if (!data) {\n    return [];\n  }\n  return [...new Set(Object.keys(data).reduce((memo, key) => {\n    localizableKeys.forEach((localizableKey) => {\n      if (key.indexOf(`${localizableKey}-`) == 0) {\n        memo.push(key.slice(localizableKey.length + 1));\n      }\n    });\n    return memo;\n  }, []))];\n}\n\nexport function transformPushBodyForLocale(body, locale) {\n  const data = body.data;\n  if (!data) {\n    return body;\n  }\n  body = deepcopy(body);\n  localizableKeys.forEach((key) => {\n    const localeValue = body.data[`${key}-${locale}`];\n    if (localeValue) {\n      body.data[key] = localeValue;\n    }\n  });\n  return stripLocalesFromBody(body);\n}\n\nexport function stripLocalesFromBody(body) {\n  if (!body.data) { return body; }\n  Object.keys(body.data).forEach((key) => {\n    localizableKeys.forEach((localizableKey) => {\n      if (key.indexOf(`${localizableKey}-`) == 0) {\n        delete body.data[key];\n      }\n    });\n  });\n  return body;\n}\n\nexport function bodiesPerLocales(body, locales = []) {\n  // Get all tranformed bodies for each locale\n  const result = locales.reduce((memo, locale) => {\n    memo[locale] = transformPushBodyForLocale(body, locale);\n    return memo;\n  }, {});\n  // Set the default locale, with the stripped body\n  result.default = stripLocalesFromBody(body);\n  return result;\n}\n\nexport function groupByLocaleIdentifier(installations, locales = []) {\n  return installations.reduce((map, installation) => {\n    let added = false;\n    locales.forEach((locale) => {\n      if (added) {\n        return;\n      }\n      if (installation.localeIdentifier && installation.localeIdentifier.indexOf(locale) === 0) {\n        added = true;\n        map[locale] = map[locale] || [];\n        map[locale].push(installation);\n      }\n    });\n    if (!added) {\n      map.default.push(installation);\n    }\n    return map;\n  }, {default: []});\n}\n\n/**\n * Check whether the deviceType parameter in qury condition is valid or not.\n * @param {Object} where A query condition\n * @param {Array} validPushTypes An array of valid push types(string)\n */\nexport function validatePushType(where = {}, validPushTypes = []) {\n  var deviceTypeField = where.deviceType || {};\n  var deviceTypes = [];\n  if (typeof deviceTypeField === 'string') {\n    deviceTypes.push(deviceTypeField);\n  } else if (Array.isArray(deviceTypeField['$in'])) {\n    deviceTypes.concat(deviceTypeField['$in']);\n  }\n  for (var i = 0; i < deviceTypes.length; i++) {\n    var deviceType = deviceTypes[i];\n    if (validPushTypes.indexOf(deviceType) < 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        deviceType + ' is not supported push type.');\n    }\n  }\n}\n\nexport function applyDeviceTokenExists(where) {\n  where = deepcopy(where);\n  if (!where.hasOwnProperty('deviceToken')) {\n    where['deviceToken'] = {'$exists': true};\n  }\n  return where;\n}\n"]} \ No newline at end of file diff --git a/lib/RestQuery.js b/lib/RestQuery.js index ffa99c6c16..f73c134abe 100644 --- a/lib/RestQuery.js +++ b/lib/RestQuery.js @@ -26,11 +26,12 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl this.clientSDK = clientSDK; this.response = null; this.findOptions = {}; + this.isWrite = false; + if (!this.auth.isMaster) { - this.findOptions.acl = this.auth.user ? [this.auth.user.id] : null; if (this.className == '_Session') { - if (!this.findOptions.acl) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'This session token is invalid.'); + if (!this.auth.user) { + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } this.restWhere = { '$and': [this.restWhere, { @@ -45,6 +46,7 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl } this.doCount = false; + this.includeAll = false; // The format for this.include is not the same as the format for the // include option - it's the paths we should include, in order, @@ -88,6 +90,9 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl case 'count': this.doCount = true; break; + case 'includeAll': + this.includeAll = true; + break; case 'distinct': case 'pipeline': case 'skip': @@ -151,6 +156,8 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl RestQuery.prototype.execute = function (executeOptions) { return Promise.resolve().then(() => { return this.buildRestWhere(); + }).then(() => { + return this.handleIncludeAll(); }).then(() => { return this.runFind(executeOptions); }).then(() => { @@ -184,17 +191,28 @@ RestQuery.prototype.buildRestWhere = function () { }); }; +// Marks the query for a write attempt, so we read the proper ACL (write instead of read) +RestQuery.prototype.forWrite = function () { + this.isWrite = true; + return this; +}; + // Uses the Auth object to get the list of roles, adds the user id RestQuery.prototype.getUserAndRoleACL = function () { - if (this.auth.isMaster || !this.auth.user) { + if (this.auth.isMaster) { return Promise.resolve(); } - return this.auth.getUserRoles().then(roles => { - // Concat with the roles to prevent duplications on multiple calls - const aclSet = new Set([].concat(this.findOptions.acl, roles)); - this.findOptions.acl = Array.from(aclSet); + + this.findOptions.acl = ['*']; + + if (this.auth.user) { + return this.auth.getUserRoles().then(roles => { + this.findOptions.acl = this.findOptions.acl.concat(roles, [this.auth.user.id]); + return; + }); + } else { return Promise.resolve(); - }); + } }; // Changes the className if redirectClassNameForKey is set. @@ -497,6 +515,9 @@ RestQuery.prototype.runFind = function (options = {}) { if (options.op) { findOptions.op = options.op; } + if (this.isWrite) { + findOptions.isWrite = true; + } return this.config.database.find(this.className, this.restWhere, findOptions).then(results => { if (this.className === '_User') { for (var result of results) { @@ -530,6 +551,29 @@ RestQuery.prototype.runCount = function () { }); }; +// Augments this.response with all pointers on an object +RestQuery.prototype.handleIncludeAll = function () { + if (!this.includeAll) { + return; + } + return this.config.database.loadSchema().then(schemaController => schemaController.getOneSchema(this.className)).then(schema => { + const includeFields = []; + const keyFields = []; + for (const field in schema.fields) { + if (schema.fields[field].type && schema.fields[field].type === 'Pointer') { + includeFields.push([field]); + keyFields.push(field); + } + } + // Add fields to include, keys, remove dups + this.include = [...new Set([...this.include, ...includeFields])]; + // if this.keys not set, then all keys are already included + if (this.keys) { + this.keys = [...new Set([...this.keys, ...keyFields])]; + } + }); +}; + // Augments this.response with data at the paths provided in this.include. RestQuery.prototype.handleInclude = function () { if (this.include.length == 0) { @@ -567,7 +611,18 @@ RestQuery.prototype.runAfterFindTrigger = function () { } // Run afterFind trigger and set the new results return triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, this.auth, this.className, this.response.results, this.config).then(results => { - this.response.results = results; + // Ensure we properly set the className back + if (this.redirectClassName) { + this.response.results = results.map(object => { + if (object instanceof Parse.Object) { + object = object.toJSON(); + } + object.className = this.redirectClassName; + return object; + }); + } else { + this.response.results = results; + } }); }; @@ -753,4 +808,5 @@ function findObjectWithKey(root, key) { } } -module.exports = RestQuery; \ No newline at end of file +module.exports = RestQuery; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/RestQuery.js"],"names":["SchemaController","require","Parse","triggers","AlwaysSelectedKeys","RestQuery","config","auth","className","restWhere","restOptions","clientSDK","response","findOptions","isWrite","isMaster","user","Error","INVALID_SESSION_TOKEN","__type","objectId","id","doCount","includeAll","include","hasOwnProperty","keysForInclude","keys","split","filter","key","length","map","slice","lastIndexOf","join","option","concat","Array","from","Set","fields","order","sort","reduce","sortMap","field","trim","score","$meta","paths","pathSet","memo","path","index","parts","Object","s","a","b","redirectKey","redirectClassNameForKey","redirectClassName","INVALID_JSON","prototype","execute","executeOptions","Promise","resolve","then","buildRestWhere","handleIncludeAll","runFind","runCount","handleInclude","runAfterFindTrigger","getUserAndRoleACL","validateClientClassCreation","replaceSelect","replaceDontSelect","replaceInQuery","replaceNotInQuery","replaceEquality","forWrite","acl","getUserRoles","roles","database","newClassName","allowClientClassCreation","systemClasses","indexOf","loadSchema","schemaController","hasClass","OPERATION_FORBIDDEN","transformInQuery","inQueryObject","results","values","result","push","isArray","findObjectWithKey","inQueryValue","where","INVALID_QUERY","additionalOptions","subqueryReadPreference","readPreference","subquery","transformNotInQuery","notInQueryObject","notInQueryValue","transformSelect","selectObject","objects","o","i","selectValue","query","transformDontSelect","dontSelectObject","dontSelectValue","cleanResultOfSensitiveUserInfo","password","userSensitiveFields","cleanResultAuthData","authData","forEach","provider","replaceEqualityConstraint","constraint","equalToObject","hasDirectConstraint","hasOperatorConstraint","options","limit","assign","op","find","filesController","expandFilesInObject","r","count","skip","c","getOneSchema","schema","includeFields","keyFields","type","pathResponse","includePath","newResponse","hasAfterFindHook","triggerExists","Types","afterFind","applicationId","pipeline","distinct","maybeRunAfterFindTrigger","object","toJSON","pointers","findPointers","pointersHash","pointer","add","includeRestOptions","keySet","set","keyPath","size","includeReadPreference","queryPromises","objectIds","all","responses","replace","includeResponse","obj","sessionToken","resp","replacePointers","answer","x","subobject","newsub","root","item","subkey","module","exports"],"mappings":"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","file":"RestQuery.js","sourcesContent":["// An object that encapsulates everything we need to run a 'find'\n// operation, encoded in the REST API format.\n\nvar SchemaController = require('./Controllers/SchemaController');\nvar Parse = require('parse/node').Parse;\nconst triggers = require('./triggers');\n\nconst AlwaysSelectedKeys = ['objectId', 'createdAt', 'updatedAt'];\n// restOptions can include:\n//   skip\n//   limit\n//   order\n//   count\n//   include\n//   keys\n//   redirectClassNameForKey\nfunction RestQuery(config, auth, className, restWhere = {}, restOptions = {}, clientSDK) {\n\n  this.config = config;\n  this.auth = auth;\n  this.className = className;\n  this.restWhere = restWhere;\n  this.restOptions = restOptions;\n  this.clientSDK = clientSDK;\n  this.response = null;\n  this.findOptions = {};\n  this.isWrite = false;\n\n  if (!this.auth.isMaster) {\n    if (this.className == '_Session') {\n      if (!this.auth.user) {\n        throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,\n          'Invalid session token');\n      }\n      this.restWhere = {\n        '$and': [this.restWhere, {\n          'user': {\n            __type: 'Pointer',\n            className: '_User',\n            objectId: this.auth.user.id\n          }\n        }]\n      };\n    }\n  }\n\n  this.doCount = false;\n  this.includeAll = false;\n\n  // The format for this.include is not the same as the format for the\n  // include option - it's the paths we should include, in order,\n  // stored as arrays, taking into account that we need to include foo\n  // before including foo.bar. Also it should dedupe.\n  // For example, passing an arg of include=foo.bar,foo.baz could lead to\n  // this.include = [['foo'], ['foo', 'baz'], ['foo', 'bar']]\n  this.include = [];\n\n  // If we have keys, we probably want to force some includes (n-1 level)\n  // See issue: https://github.com/parse-community/parse-server/issues/3185\n  if (restOptions.hasOwnProperty('keys')) {\n    const keysForInclude = restOptions.keys.split(',').filter((key) => {\n      // At least 2 components\n      return key.split(\".\").length > 1;\n    }).map((key) => {\n      // Slice the last component (a.b.c -> a.b)\n      // Otherwise we'll include one level too much.\n      return key.slice(0, key.lastIndexOf(\".\"));\n    }).join(',');\n\n    // Concat the possibly present include string with the one from the keys\n    // Dedup / sorting is handle in 'include' case.\n    if (keysForInclude.length > 0) {\n      if (!restOptions.include || restOptions.include.length == 0) {\n        restOptions.include = keysForInclude;\n      } else {\n        restOptions.include += \",\" + keysForInclude;\n      }\n    }\n  }\n\n  for (var option in restOptions) {\n    switch(option) {\n    case 'keys': {\n      const keys = restOptions.keys.split(',').concat(AlwaysSelectedKeys);\n      this.keys = Array.from(new Set(keys));\n      break;\n    }\n    case 'count':\n      this.doCount = true;\n      break;\n    case 'includeAll':\n      this.includeAll = true;\n      break;\n    case 'distinct':\n    case 'pipeline':\n    case 'skip':\n    case 'limit':\n    case 'readPreference':\n      this.findOptions[option] = restOptions[option];\n      break;\n    case 'order':\n      var fields = restOptions.order.split(',');\n      this.findOptions.sort = fields.reduce((sortMap, field) => {\n        field = field.trim();\n        if (field === '$score') {\n          sortMap.score = {$meta: 'textScore'};\n        } else if (field[0] == '-') {\n          sortMap[field.slice(1)] = -1;\n        } else {\n          sortMap[field] = 1;\n        }\n        return sortMap;\n      }, {});\n      break;\n    case 'include': {\n      const paths = restOptions.include.split(',');\n      // Load the existing includes (from keys)\n      const pathSet = paths.reduce((memo, path) => {\n        // Split each paths on . (a.b.c -> [a,b,c])\n        // reduce to create all paths\n        // ([a,b,c] -> {a: true, 'a.b': true, 'a.b.c': true})\n        return path.split('.').reduce((memo, path, index, parts) => {\n          memo[parts.slice(0, index + 1).join('.')] = true;\n          return memo;\n        }, memo);\n      }, {});\n\n      this.include = Object.keys(pathSet).map((s) => {\n        return s.split('.');\n      }).sort((a, b) => {\n        return a.length - b.length; // Sort by number of components\n      });\n      break;\n    }\n    case 'redirectClassNameForKey':\n      this.redirectKey = restOptions.redirectClassNameForKey;\n      this.redirectClassName = null;\n      break;\n    case 'includeReadPreference':\n    case 'subqueryReadPreference':\n      break;\n    default:\n      throw new Parse.Error(Parse.Error.INVALID_JSON,\n        'bad option: ' + option);\n    }\n  }\n}\n\n// A convenient method to perform all the steps of processing a query\n// in order.\n// Returns a promise for the response - an object with optional keys\n// 'results' and 'count'.\n// TODO: consolidate the replaceX functions\nRestQuery.prototype.execute = function(executeOptions) {\n  return Promise.resolve().then(() => {\n    return this.buildRestWhere();\n  }).then(() => {\n    return this.handleIncludeAll();\n  }).then(() => {\n    return this.runFind(executeOptions);\n  }).then(() => {\n    return this.runCount();\n  }).then(() => {\n    return this.handleInclude();\n  }).then(() => {\n    return this.runAfterFindTrigger();\n  }).then(() => {\n    return this.response;\n  });\n};\n\nRestQuery.prototype.buildRestWhere = function() {\n  return Promise.resolve().then(() => {\n    return this.getUserAndRoleACL();\n  }).then(() => {\n    return this.redirectClassNameForKey();\n  }).then(() => {\n    return this.validateClientClassCreation();\n  }).then(() => {\n    return this.replaceSelect();\n  }).then(() => {\n    return this.replaceDontSelect();\n  }).then(() => {\n    return this.replaceInQuery();\n  }).then(() => {\n    return this.replaceNotInQuery();\n  }).then(() => {\n    return this.replaceEquality();\n  });\n}\n\n// Marks the query for a write attempt, so we read the proper ACL (write instead of read)\nRestQuery.prototype.forWrite = function() {\n  this.isWrite = true;\n  return this;\n}\n\n// Uses the Auth object to get the list of roles, adds the user id\nRestQuery.prototype.getUserAndRoleACL = function() {\n  if (this.auth.isMaster) {\n    return Promise.resolve();\n  }\n\n  this.findOptions.acl = ['*'];\n\n  if (this.auth.user) {\n    return this.auth.getUserRoles().then((roles) => {\n      this.findOptions.acl = this.findOptions.acl.concat(roles, [this.auth.user.id]);\n      return;\n    });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Changes the className if redirectClassNameForKey is set.\n// Returns a promise.\nRestQuery.prototype.redirectClassNameForKey = function() {\n  if (!this.redirectKey) {\n    return Promise.resolve();\n  }\n\n  // We need to change the class name based on the schema\n  return this.config.database.redirectClassNameForKey(this.className, this.redirectKey)\n    .then((newClassName) => {\n      this.className = newClassName;\n      this.redirectClassName = newClassName;\n    });\n};\n\n// Validates this operation against the allowClientClassCreation config.\nRestQuery.prototype.validateClientClassCreation = function() {\n  if (this.config.allowClientClassCreation === false && !this.auth.isMaster\n      && SchemaController.systemClasses.indexOf(this.className) === -1) {\n    return this.config.database.loadSchema()\n      .then(schemaController => schemaController.hasClass(this.className))\n      .then(hasClass => {\n        if (hasClass !== true) {\n          throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n            'This user is not allowed to access ' +\n                                'non-existent class: ' + this.className);\n        }\n      });\n  } else {\n    return Promise.resolve();\n  }\n};\n\nfunction transformInQuery(inQueryObject, className, results) {\n  var values = [];\n  for (var result of results) {\n    values.push({\n      __type: 'Pointer',\n      className: className,\n      objectId: result.objectId\n    });\n  }\n  delete inQueryObject['$inQuery'];\n  if (Array.isArray(inQueryObject['$in'])) {\n    inQueryObject['$in'] = inQueryObject['$in'].concat(values);\n  } else {\n    inQueryObject['$in'] = values;\n  }\n}\n\n// Replaces a $inQuery clause by running the subquery, if there is an\n// $inQuery clause.\n// The $inQuery clause turns into an $in with values that are just\n// pointers to the objects returned in the subquery.\nRestQuery.prototype.replaceInQuery = function() {\n  var inQueryObject = findObjectWithKey(this.restWhere, '$inQuery');\n  if (!inQueryObject) {\n    return;\n  }\n\n  // The inQuery value must have precisely two keys - where and className\n  var inQueryValue = inQueryObject['$inQuery'];\n  if (!inQueryValue.where || !inQueryValue.className) {\n    throw new Parse.Error(Parse.Error.INVALID_QUERY,\n      'improper usage of $inQuery');\n  }\n\n  const additionalOptions = {\n    redirectClassNameForKey: inQueryValue.redirectClassNameForKey,\n    keys: 'objectId'\n  };\n\n  if (this.restOptions.subqueryReadPreference) {\n    additionalOptions.readPreference = this.restOptions.subqueryReadPreference;\n    additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference;\n  }\n\n  var subquery = new RestQuery(\n    this.config, this.auth, inQueryValue.className,\n    inQueryValue.where, additionalOptions);\n  return subquery.execute().then((response) => {\n    transformInQuery(inQueryObject, subquery.className, response.results);\n    // Recurse to repeat\n    return this.replaceInQuery();\n  });\n};\n\nfunction transformNotInQuery(notInQueryObject, className, results) {\n  var values = [];\n  for (var result of results) {\n    values.push({\n      __type: 'Pointer',\n      className: className,\n      objectId: result.objectId\n    });\n  }\n  delete notInQueryObject['$notInQuery'];\n  if (Array.isArray(notInQueryObject['$nin'])) {\n    notInQueryObject['$nin'] = notInQueryObject['$nin'].concat(values);\n  } else {\n    notInQueryObject['$nin'] = values;\n  }\n}\n\n// Replaces a $notInQuery clause by running the subquery, if there is an\n// $notInQuery clause.\n// The $notInQuery clause turns into a $nin with values that are just\n// pointers to the objects returned in the subquery.\nRestQuery.prototype.replaceNotInQuery = function() {\n  var notInQueryObject = findObjectWithKey(this.restWhere, '$notInQuery');\n  if (!notInQueryObject) {\n    return;\n  }\n\n  // The notInQuery value must have precisely two keys - where and className\n  var notInQueryValue = notInQueryObject['$notInQuery'];\n  if (!notInQueryValue.where || !notInQueryValue.className) {\n    throw new Parse.Error(Parse.Error.INVALID_QUERY,\n      'improper usage of $notInQuery');\n  }\n\n  const additionalOptions = {\n    redirectClassNameForKey: notInQueryValue.redirectClassNameForKey,\n    keys: 'objectId'\n  };\n\n  if (this.restOptions.subqueryReadPreference) {\n    additionalOptions.readPreference = this.restOptions.subqueryReadPreference;\n    additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference;\n  }\n\n  var subquery = new RestQuery(\n    this.config, this.auth, notInQueryValue.className,\n    notInQueryValue.where, additionalOptions);\n  return subquery.execute().then((response) => {\n    transformNotInQuery(notInQueryObject, subquery.className, response.results);\n    // Recurse to repeat\n    return this.replaceNotInQuery();\n  });\n};\n\nconst transformSelect = (selectObject, key ,objects) => {\n  var values = [];\n  for (var result of objects) {\n    values.push(key.split('.').reduce((o,i)=>o[i], result));\n  }\n  delete selectObject['$select'];\n  if (Array.isArray(selectObject['$in'])) {\n    selectObject['$in'] = selectObject['$in'].concat(values);\n  } else {\n    selectObject['$in'] = values;\n  }\n}\n\n// Replaces a $select clause by running the subquery, if there is a\n// $select clause.\n// The $select clause turns into an $in with values selected out of\n// the subquery.\n// Returns a possible-promise.\nRestQuery.prototype.replaceSelect = function() {\n  var selectObject = findObjectWithKey(this.restWhere, '$select');\n  if (!selectObject) {\n    return;\n  }\n\n  // The select value must have precisely two keys - query and key\n  var selectValue = selectObject['$select'];\n  // iOS SDK don't send where if not set, let it pass\n  if (!selectValue.query ||\n      !selectValue.key ||\n      typeof selectValue.query !== 'object' ||\n      !selectValue.query.className ||\n      Object.keys(selectValue).length !== 2) {\n    throw new Parse.Error(Parse.Error.INVALID_QUERY,\n      'improper usage of $select');\n  }\n\n  const additionalOptions = {\n    redirectClassNameForKey: selectValue.query.redirectClassNameForKey,\n    keys: selectValue.key\n  };\n\n  if (this.restOptions.subqueryReadPreference) {\n    additionalOptions.readPreference = this.restOptions.subqueryReadPreference;\n    additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference;\n  }\n\n  var subquery = new RestQuery(\n    this.config, this.auth, selectValue.query.className,\n    selectValue.query.where, additionalOptions);\n  return subquery.execute().then((response) => {\n    transformSelect(selectObject, selectValue.key, response.results);\n    // Keep replacing $select clauses\n    return this.replaceSelect();\n  })\n};\n\nconst transformDontSelect = (dontSelectObject, key, objects) => {\n  var values = [];\n  for (var result of objects) {\n    values.push(key.split('.').reduce((o,i)=>o[i], result));\n  }\n  delete dontSelectObject['$dontSelect'];\n  if (Array.isArray(dontSelectObject['$nin'])) {\n    dontSelectObject['$nin'] = dontSelectObject['$nin'].concat(values);\n  } else {\n    dontSelectObject['$nin'] = values;\n  }\n}\n\n// Replaces a $dontSelect clause by running the subquery, if there is a\n// $dontSelect clause.\n// The $dontSelect clause turns into an $nin with values selected out of\n// the subquery.\n// Returns a possible-promise.\nRestQuery.prototype.replaceDontSelect = function() {\n  var dontSelectObject = findObjectWithKey(this.restWhere, '$dontSelect');\n  if (!dontSelectObject) {\n    return;\n  }\n\n  // The dontSelect value must have precisely two keys - query and key\n  var dontSelectValue = dontSelectObject['$dontSelect'];\n  if (!dontSelectValue.query ||\n      !dontSelectValue.key ||\n      typeof dontSelectValue.query !== 'object' ||\n      !dontSelectValue.query.className ||\n      Object.keys(dontSelectValue).length !== 2) {\n    throw new Parse.Error(Parse.Error.INVALID_QUERY,\n      'improper usage of $dontSelect');\n  }\n  const additionalOptions = {\n    redirectClassNameForKey: dontSelectValue.query.redirectClassNameForKey,\n    keys: dontSelectValue.key\n  };\n\n  if (this.restOptions.subqueryReadPreference) {\n    additionalOptions.readPreference = this.restOptions.subqueryReadPreference;\n    additionalOptions.subqueryReadPreference = this.restOptions.subqueryReadPreference;\n  }\n\n  var subquery = new RestQuery(\n    this.config, this.auth, dontSelectValue.query.className,\n    dontSelectValue.query.where, additionalOptions);\n  return subquery.execute().then((response) => {\n    transformDontSelect(dontSelectObject, dontSelectValue.key, response.results);\n    // Keep replacing $dontSelect clauses\n    return this.replaceDontSelect();\n  })\n};\n\nconst cleanResultOfSensitiveUserInfo = function (result, auth, config) {\n  delete result.password;\n\n  if (auth.isMaster || (auth.user && auth.user.id === result.objectId)) {\n    return;\n  }\n\n  for (const field of config.userSensitiveFields) {\n    delete result[field];\n  }\n};\n\nconst cleanResultAuthData = function (result) {\n  if (result.authData) {\n    Object.keys(result.authData).forEach((provider) => {\n      if (result.authData[provider] === null) {\n        delete result.authData[provider];\n      }\n    });\n\n    if (Object.keys(result.authData).length == 0) {\n      delete result.authData;\n    }\n  }\n};\n\nconst replaceEqualityConstraint = (constraint) => {\n  if (typeof constraint !== 'object') {\n    return constraint;\n  }\n  const equalToObject = {};\n  let hasDirectConstraint = false;\n  let hasOperatorConstraint = false;\n  for (const key in constraint) {\n    if (key.indexOf('$') !== 0) {\n      hasDirectConstraint = true;\n      equalToObject[key] = constraint[key];\n    } else {\n      hasOperatorConstraint = true;\n    }\n  }\n  if (hasDirectConstraint && hasOperatorConstraint) {\n    constraint['$eq'] = equalToObject;\n    Object.keys(equalToObject).forEach((key) => {\n      delete constraint[key];\n    });\n  }\n  return constraint;\n}\n\nRestQuery.prototype.replaceEquality = function() {\n  if (typeof this.restWhere !== 'object') {\n    return;\n  }\n  for (const key in this.restWhere) {\n    this.restWhere[key] = replaceEqualityConstraint(this.restWhere[key]);\n  }\n}\n\n// Returns a promise for whether it was successful.\n// Populates this.response with an object that only has 'results'.\nRestQuery.prototype.runFind = function(options = {}) {\n  if (this.findOptions.limit === 0) {\n    this.response = {results: []};\n    return Promise.resolve();\n  }\n  const findOptions = Object.assign({}, this.findOptions);\n  if (this.keys) {\n    findOptions.keys = this.keys.map((key) => {\n      return key.split('.')[0];\n    });\n  }\n  if (options.op) {\n    findOptions.op = options.op;\n  }\n  if (this.isWrite) {\n    findOptions.isWrite = true;\n  }\n  return this.config.database.find(this.className, this.restWhere, findOptions)\n    .then((results) => {\n      if (this.className === '_User') {\n        for (var result of results) {\n          cleanResultOfSensitiveUserInfo(result, this.auth, this.config);\n          cleanResultAuthData(result);\n        }\n      }\n\n      this.config.filesController.expandFilesInObject(this.config, results);\n\n      if (this.redirectClassName) {\n        for (var r of results) {\n          r.className = this.redirectClassName;\n        }\n      }\n      this.response = {results: results};\n    });\n};\n\n// Returns a promise for whether it was successful.\n// Populates this.response.count with the count\nRestQuery.prototype.runCount = function() {\n  if (!this.doCount) {\n    return;\n  }\n  this.findOptions.count = true;\n  delete this.findOptions.skip;\n  delete this.findOptions.limit;\n  return this.config.database.find(this.className, this.restWhere, this.findOptions)\n    .then((c) => {\n      this.response.count = c;\n    });\n};\n\n// Augments this.response with all pointers on an object\nRestQuery.prototype.handleIncludeAll = function() {\n  if (!this.includeAll) {\n    return;\n  }\n  return this.config.database.loadSchema()\n    .then(schemaController => schemaController.getOneSchema(this.className))\n    .then(schema => {\n      const includeFields = [];\n      const keyFields = [];\n      for (const field in schema.fields) {\n        if (schema.fields[field].type && schema.fields[field].type === 'Pointer') {\n          includeFields.push([field]);\n          keyFields.push(field);\n        }\n      }\n      // Add fields to include, keys, remove dups\n      this.include = [...new Set([...this.include, ...includeFields])];\n      // if this.keys not set, then all keys are already included\n      if (this.keys) {\n        this.keys = [...new Set([...this.keys, ...keyFields])];\n      }\n    });\n};\n\n// Augments this.response with data at the paths provided in this.include.\nRestQuery.prototype.handleInclude = function() {\n  if (this.include.length == 0) {\n    return;\n  }\n\n  var pathResponse = includePath(this.config, this.auth,\n    this.response, this.include[0], this.restOptions);\n  if (pathResponse.then) {\n    return pathResponse.then((newResponse) => {\n      this.response = newResponse;\n      this.include = this.include.slice(1);\n      return this.handleInclude();\n    });\n  } else if (this.include.length > 0) {\n    this.include = this.include.slice(1);\n    return this.handleInclude();\n  }\n\n  return pathResponse;\n};\n\n//Returns a promise of a processed set of results\nRestQuery.prototype.runAfterFindTrigger = function() {\n  if (!this.response) {\n    return;\n  }\n  // Avoid doing any setup for triggers if there is no 'afterFind' trigger for this class.\n  const hasAfterFindHook = triggers.triggerExists(this.className, triggers.Types.afterFind, this.config.applicationId);\n  if (!hasAfterFindHook) {\n    return Promise.resolve();\n  }\n  // Skip Aggregate and Distinct Queries\n  if (this.findOptions.pipeline || this.findOptions.distinct) {\n    return Promise.resolve();\n  }\n  // Run afterFind trigger and set the new results\n  return triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, this.auth, this.className,this.response.results, this.config).then((results) => {\n    // Ensure we properly set the className back\n    if (this.redirectClassName) {\n      this.response.results = results.map((object) => {\n        if (object instanceof Parse.Object) {\n          object = object.toJSON();\n        }\n        object.className = this.redirectClassName;\n        return object;\n      });\n    } else {\n      this.response.results = results;\n    }\n  });\n};\n\n// Adds included values to the response.\n// Path is a list of field names.\n// Returns a promise for an augmented response.\nfunction includePath(config, auth, response, path, restOptions = {}) {\n  var pointers = findPointers(response.results, path);\n  if (pointers.length == 0) {\n    return response;\n  }\n  const pointersHash = {};\n  for (var pointer of pointers) {\n    if (!pointer) {\n      continue;\n    }\n    const className = pointer.className;\n    // only include the good pointers\n    if (className) {\n      pointersHash[className] = pointersHash[className] || new Set();\n      pointersHash[className].add(pointer.objectId);\n    }\n  }\n  const includeRestOptions = {};\n  if (restOptions.keys) {\n    const keys = new Set(restOptions.keys.split(','));\n    const keySet = Array.from(keys).reduce((set, key) => {\n      const keyPath = key.split('.');\n      let i = 0;\n      for (i; i < path.length; i++) {\n        if (path[i] != keyPath[i]) {\n          return set;\n        }\n      }\n      if (i < keyPath.length) {\n        set.add(keyPath[i]);\n      }\n      return set;\n    }, new Set());\n    if (keySet.size > 0) {\n      includeRestOptions.keys = Array.from(keySet).join(',');\n    }\n  }\n\n  if (restOptions.includeReadPreference) {\n    includeRestOptions.readPreference = restOptions.includeReadPreference;\n    includeRestOptions.includeReadPreference = restOptions.includeReadPreference;\n  }\n\n  const queryPromises = Object.keys(pointersHash).map((className) => {\n    const objectIds = Array.from(pointersHash[className]);\n    let where;\n    if (objectIds.length === 1) {\n      where = {'objectId': objectIds[0]};\n    } else {\n      where = {'objectId': {'$in': objectIds}};\n    }\n    var query = new RestQuery(config, auth, className, where, includeRestOptions);\n    return query.execute({op: 'get'}).then((results) => {\n      results.className = className;\n      return Promise.resolve(results);\n    })\n  })\n\n  // Get the objects for all these object ids\n  return Promise.all(queryPromises).then((responses) => {\n    var replace = responses.reduce((replace, includeResponse) => {\n      for (var obj of includeResponse.results) {\n        obj.__type = 'Object';\n        obj.className = includeResponse.className;\n\n        if (obj.className == \"_User\" && !auth.isMaster) {\n          delete obj.sessionToken;\n          delete obj.authData;\n        }\n        replace[obj.objectId] = obj;\n      }\n      return replace;\n    }, {})\n\n    var resp = {\n      results: replacePointers(response.results, path, replace)\n    };\n    if (response.count) {\n      resp.count = response.count;\n    }\n    return resp;\n  });\n}\n\n// Object may be a list of REST-format object to find pointers in, or\n// it may be a single object.\n// If the path yields things that aren't pointers, this throws an error.\n// Path is a list of fields to search into.\n// Returns a list of pointers in REST format.\nfunction findPointers(object, path) {\n  if (object instanceof Array) {\n    var answer = [];\n    for (var x of object) {\n      answer = answer.concat(findPointers(x, path));\n    }\n    return answer;\n  }\n\n  if (typeof object !== 'object' || !object) {\n    return [];\n  }\n\n  if (path.length == 0) {\n    if (object === null || object.__type == 'Pointer') {\n      return [object];\n    }\n    return [];\n  }\n\n  var subobject = object[path[0]];\n  if (!subobject) {\n    return [];\n  }\n  return findPointers(subobject, path.slice(1));\n}\n\n// Object may be a list of REST-format objects to replace pointers\n// in, or it may be a single object.\n// Path is a list of fields to search into.\n// replace is a map from object id -> object.\n// Returns something analogous to object, but with the appropriate\n// pointers inflated.\nfunction replacePointers(object, path, replace) {\n  if (object instanceof Array) {\n    return object.map((obj) => replacePointers(obj, path, replace))\n      .filter((obj) => typeof obj !== 'undefined');\n  }\n\n  if (typeof object !== 'object' || !object) {\n    return object;\n  }\n\n  if (path.length === 0) {\n    if (object && object.__type === 'Pointer') {\n      return replace[object.objectId];\n    }\n    return object;\n  }\n\n  var subobject = object[path[0]];\n  if (!subobject) {\n    return object;\n  }\n  var newsub = replacePointers(subobject, path.slice(1), replace);\n  var answer = {};\n  for (var key in object) {\n    if (key == path[0]) {\n      answer[key] = newsub;\n    } else {\n      answer[key] = object[key];\n    }\n  }\n  return answer;\n}\n\n// Finds a subobject that has the given key, if there is one.\n// Returns undefined otherwise.\nfunction findObjectWithKey(root, key) {\n  if (typeof root !== 'object') {\n    return;\n  }\n  if (root instanceof Array) {\n    for (var item of root) {\n      const answer = findObjectWithKey(item, key);\n      if (answer) {\n        return answer;\n      }\n    }\n  }\n  if (root && root[key]) {\n    return root;\n  }\n  for (var subkey in root) {\n    const answer = findObjectWithKey(root[subkey], key);\n    if (answer) {\n      return answer;\n    }\n  }\n}\n\nmodule.exports = RestQuery;\n"]} \ No newline at end of file diff --git a/lib/RestWrite.js b/lib/RestWrite.js index fdebfca115..310612fe9a 100644 --- a/lib/RestWrite.js +++ b/lib/RestWrite.js @@ -286,10 +286,23 @@ RestWrite.prototype.findUsersWithAuthData = function (authData) { return findPromise; }; +RestWrite.prototype.filteredObjectsByACL = function (objects) { + if (this.auth.isMaster) { + return objects; + } + return objects.filter(object => { + if (!object.ACL) { + return true; // legacy users that have no ACL field on them + } + // Regular users that have been locked out. + return object.ACL && Object.keys(object.ACL).length > 0; + }); +}; + RestWrite.prototype.handleAuthData = function (authData) { let results; return this.findUsersWithAuthData(authData).then(r => { - results = r; + results = this.filteredObjectsByACL(r); if (results.length > 1) { // More than 1 user with the passed id's throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, 'this auth is already used'); @@ -917,7 +930,7 @@ RestWrite.prototype.runDatabaseOperation = function () { this.config.cacheController.role.clear(); } - if (this.className === '_User' && this.query && !this.auth.couldUpdateUserId(this.query.objectId)) { + if (this.className === '_User' && this.query && this.auth.isUnauthenticated()) { throw new Parse.Error(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`); } @@ -934,7 +947,7 @@ RestWrite.prototype.runDatabaseOperation = function () { if (this.query) { // Force the user to not lockout // Matched with parse.com - if (this.className === '_User' && this.data.ACL) { + if (this.className === '_User' && this.data.ACL && this.auth.isMaster !== true) { this.data.ACL[this.query.objectId] = { read: true, write: true }; } // update password timestamp if user password is being changed @@ -1164,4 +1177,5 @@ RestWrite.prototype._updateResponseWithData = function (response, data) { exports.default = RestWrite; -module.exports = RestWrite; \ No newline at end of file +module.exports = RestWrite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/RestWrite.js"],"names":["SchemaController","require","deepcopy","Auth","cryptoUtils","passwordCrypto","Parse","triggers","ClientSDK","RestWrite","config","auth","className","query","data","originalData","clientSDK","options","isReadOnly","Error","OPERATION_FORBIDDEN","storage","runOptions","allowObjectId","objectId","INVALID_KEY_NAME","response","updatedAt","_encode","Date","iso","prototype","execute","Promise","resolve","then","getUserAndRoleACL","validateClientClassCreation","handleInstallation","handleSession","validateAuthData","runBeforeTrigger","validateSchema","setRequiredFieldsIfNeeded","transformUser","expandFilesForExistingObjects","destroyDuplicatedSessions","runDatabaseOperation","createSessionTokenIfNeeded","handleFollowup","runAfterTrigger","cleanUserAuthData","isMaster","acl","user","getUserRoles","roles","concat","id","allowClientClassCreation","systemClasses","indexOf","database","loadSchema","schemaController","hasClass","validateObject","triggerExists","Types","beforeSave","applicationId","extraData","originalObject","updatedObject","buildUpdatedObject","inflate","maybeRunTrigger","object","fieldsChangedByTrigger","_","reduce","result","value","key","isEqual","push","createdAt","newObjectId","objectIdSize","authData","username","isEmpty","USERNAME_MISSING","password","PASSWORD_MISSING","Object","keys","length","providers","canHandleAuthData","canHandle","provider","providerAuthData","hasToken","handleAuthData","UNSUPPORTED_SERVICE","handleAuthDataValidation","validations","map","authDataManager","getValidatorForProvider","all","findUsersWithAuthData","memo","queryKey","filter","q","findPromise","find","filteredObjectsByACL","objects","ACL","results","r","ACCOUNT_ALREADY_LINKED","join","userResult","mutatedAuthData","forEach","providerData","userAuthData","hasMutatedAuthData","userId","location","update","promise","error","RestQuery","master","__type","session","cacheController","del","sessionToken","undefined","_validatePasswordPolicy","hash","hashedPassword","_hashed_password","_validateUserName","_validateEmail","randomString","responseShouldHaveUsername","limit","USERNAME_TAKEN","email","__op","match","reject","INVALID_EMAIL_ADDRESS","EMAIL_TAKEN","userController","setEmailVerifyToken","passwordPolicy","_validatePasswordRequirements","_validatePasswordHistory","policyError","patternValidator","validatorCallback","VALIDATION_ERROR","doNotAllowUsername","maxPasswordHistory","oldPasswords","_password_history","take","newPassword","promises","compare","catch","err","preventLoginWithUnverifiedEmail","verifyUserEmails","createSessionToken","installationId","sessionData","createSession","createdWith","destroy","revokeSessionOnPasswordReset","sessionQuery","bind","sendVerificationEmail","INVALID_SESSION_TOKEN","additionalSessionData","action","INTERNAL_SERVER_ERROR","status","deviceToken","toLowerCase","deviceType","idMatch","objectIdMatch","installationIdMatch","deviceTokenMatches","orQueries","OBJECT_NOT_FOUND","delQuery","appIdentifier","code","objId","filesController","expandFilesInObject","role","clear","isUnauthenticated","SESSION_MISSING","download","downloadName","name","INVALID_ACL","read","write","maxPasswordAge","_password_changed_at","defer","shift","_updateResponseWithData","create","DUPLICATE_VALUE","userInfo","duplicated_field","hasAfterSaveHook","afterSave","hasLiveQuery","liveQueryController","_handleSaveResponse","onAfterSave","logger","warn","middle","mount","sanitizedData","test","_decode","splittedKey","split","parentProp","parentVal","get","set","clientSupportsDelete","supportsForwardDelete","fieldName","dataValue","hasOwnProperty","module","exports"],"mappings":"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","file":"RestWrite.js","sourcesContent":["// A RestWrite encapsulates everything we need to run an operation\n// that writes to the database.\n// This could be either a \"create\" or an \"update\".\n\nvar SchemaController = require('./Controllers/SchemaController');\nvar deepcopy = require('deepcopy');\n\nconst Auth = require('./Auth');\nvar cryptoUtils = require('./cryptoUtils');\nvar passwordCrypto = require('./password');\nvar Parse = require('parse/node');\nvar triggers = require('./triggers');\nvar ClientSDK = require('./ClientSDK');\nimport RestQuery from './RestQuery';\nimport _         from 'lodash';\nimport logger    from './logger';\n\n// query and data are both provided in REST API format. So data\n// types are encoded by plain old objects.\n// If query is null, this is a \"create\" and the data in data should be\n// created.\n// Otherwise this is an \"update\" - the object matching the query\n// should get updated with data.\n// RestWrite will handle objectId, createdAt, and updatedAt for\n// everything. It also knows to use triggers and special modifications\n// for the _User class.\nfunction RestWrite(config, auth, className, query, data, originalData, clientSDK, options) {\n  if (auth.isReadOnly) {\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'Cannot perform a write operation when using readOnlyMasterKey');\n  }\n  this.config = config;\n  this.auth = auth;\n  this.className = className;\n  this.clientSDK = clientSDK;\n  this.storage = {};\n  this.runOptions = {};\n  const allowObjectId = options && options.allowObjectId === true;\n  if (!query && data.objectId && !allowObjectId) {\n    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'objectId is an invalid field name.');\n  }\n\n  // When the operation is complete, this.response may have several\n  // fields.\n  // response: the actual data to be returned\n  // status: the http status code. if not present, treated like a 200\n  // location: the location header. if not present, no location header\n  this.response = null;\n\n  // Processing this operation may mutate our data, so we operate on a\n  // copy\n  this.query = deepcopy(query);\n  this.data = deepcopy(data);\n  // We never change originalData, so we do not need a deep copy\n  this.originalData = originalData;\n\n  // The timestamp we'll use for this whole operation\n  this.updatedAt = Parse._encode(new Date()).iso;\n}\n\n// A convenient method to perform all the steps of processing the\n// write, in order.\n// Returns a promise for a {response, status, location} object.\n// status and location are optional.\nRestWrite.prototype.execute = function() {\n  return Promise.resolve().then(() => {\n    return this.getUserAndRoleACL();\n  }).then(() => {\n    return this.validateClientClassCreation();\n  }).then(() => {\n    return this.handleInstallation();\n  }).then(() => {\n    return this.handleSession();\n  }).then(() => {\n    return this.validateAuthData();\n  }).then(() => {\n    return this.runBeforeTrigger();\n  }).then(() => {\n    return this.validateSchema();\n  }).then(() => {\n    return this.setRequiredFieldsIfNeeded();\n  }).then(() => {\n    return this.transformUser();\n  }).then(() => {\n    return this.expandFilesForExistingObjects();\n  }).then(() => {\n    return this.destroyDuplicatedSessions();\n  }).then(() => {\n    return this.runDatabaseOperation();\n  }).then(() => {\n    return this.createSessionTokenIfNeeded();\n  }).then(() => {\n    return this.handleFollowup();\n  }).then(() => {\n    return this.runAfterTrigger();\n  }).then(() => {\n    return this.cleanUserAuthData();\n  }).then(() => {\n    return this.response;\n  })\n};\n\n// Uses the Auth object to get the list of roles, adds the user id\nRestWrite.prototype.getUserAndRoleACL = function() {\n  if (this.auth.isMaster) {\n    return Promise.resolve();\n  }\n\n  this.runOptions.acl = ['*'];\n\n  if (this.auth.user) {\n    return this.auth.getUserRoles().then((roles) => {\n      this.runOptions.acl = this.runOptions.acl.concat(roles, [this.auth.user.id]);\n      return;\n    });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Validates this operation against the allowClientClassCreation config.\nRestWrite.prototype.validateClientClassCreation = function() {\n  if (this.config.allowClientClassCreation === false && !this.auth.isMaster\n      && SchemaController.systemClasses.indexOf(this.className) === -1) {\n    return this.config.database.loadSchema()\n      .then(schemaController => schemaController.hasClass(this.className))\n      .then(hasClass => {\n        if (hasClass !== true) {\n          throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN,\n            'This user is not allowed to access ' +\n                                'non-existent class: ' + this.className);\n        }\n      });\n  } else {\n    return Promise.resolve();\n  }\n};\n\n// Validates this operation against the schema.\nRestWrite.prototype.validateSchema = function() {\n  return this.config.database.validateObject(this.className, this.data, this.query, this.runOptions);\n};\n\n// Runs any beforeSave triggers against this operation.\n// Any change leads to our data being mutated.\nRestWrite.prototype.runBeforeTrigger = function() {\n  if (this.response) {\n    return;\n  }\n\n  // Avoid doing any setup for triggers if there is no 'beforeSave' trigger for this class.\n  if (!triggers.triggerExists(this.className, triggers.Types.beforeSave, this.config.applicationId)) {\n    return Promise.resolve();\n  }\n\n  // Cloud code gets a bit of extra data for its objects\n  var extraData = {className: this.className};\n  if (this.query && this.query.objectId) {\n    extraData.objectId = this.query.objectId;\n  }\n\n  let originalObject = null;\n  const updatedObject = this.buildUpdatedObject(extraData);\n  if (this.query && this.query.objectId) {\n    // This is an update for existing object.\n    originalObject = triggers.inflate(extraData, this.originalData);\n  }\n\n  return Promise.resolve().then(() => {\n    return triggers.maybeRunTrigger(triggers.Types.beforeSave, this.auth, updatedObject, originalObject, this.config);\n  }).then((response) => {\n    if (response && response.object) {\n      this.storage.fieldsChangedByTrigger = _.reduce(response.object, (result, value, key) => {\n        if (!_.isEqual(this.data[key], value)) {\n          result.push(key);\n        }\n        return result;\n      }, []);\n      this.data = response.object;\n      // We should delete the objectId for an update write\n      if (this.query && this.query.objectId) {\n        delete this.data.objectId\n      }\n    }\n  });\n};\n\nRestWrite.prototype.setRequiredFieldsIfNeeded = function() {\n  if (this.data) {\n    // Add default fields\n    this.data.updatedAt = this.updatedAt;\n    if (!this.query) {\n      this.data.createdAt = this.updatedAt;\n\n      // Only assign new objectId if we are creating new object\n      if (!this.data.objectId) {\n        this.data.objectId = cryptoUtils.newObjectId(this.config.objectIdSize);\n      }\n    }\n  }\n  return Promise.resolve();\n};\n\n// Transforms auth data for a user object.\n// Does nothing if this isn't a user object.\n// Returns a promise for when we're done if it can't finish this tick.\nRestWrite.prototype.validateAuthData = function() {\n  if (this.className !== '_User') {\n    return;\n  }\n\n  if (!this.query && !this.data.authData) {\n    if (typeof this.data.username !== 'string' || _.isEmpty(this.data.username)) {\n      throw new Parse.Error(Parse.Error.USERNAME_MISSING,\n        'bad or missing username');\n    }\n    if (typeof this.data.password !== 'string' || _.isEmpty(this.data.password)) {\n      throw new Parse.Error(Parse.Error.PASSWORD_MISSING,\n        'password is required');\n    }\n  }\n\n  if (!this.data.authData || !Object.keys(this.data.authData).length) {\n    return;\n  }\n\n  var authData = this.data.authData;\n  var providers = Object.keys(authData);\n  if (providers.length > 0) {\n    const canHandleAuthData = providers.reduce((canHandle, provider) => {\n      var providerAuthData = authData[provider];\n      var hasToken = (providerAuthData && providerAuthData.id);\n      return canHandle && (hasToken || providerAuthData == null);\n    }, true);\n    if (canHandleAuthData) {\n      return this.handleAuthData(authData);\n    }\n  }\n  throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE,\n    'This authentication method is unsupported.');\n};\n\nRestWrite.prototype.handleAuthDataValidation = function(authData) {\n  const validations = Object.keys(authData).map((provider) => {\n    if (authData[provider] === null) {\n      return Promise.resolve();\n    }\n    const validateAuthData = this.config.authDataManager.getValidatorForProvider(provider);\n    if (!validateAuthData) {\n      throw new Parse.Error(Parse.Error.UNSUPPORTED_SERVICE,\n        'This authentication method is unsupported.');\n    }\n    return validateAuthData(authData[provider]);\n  });\n  return Promise.all(validations);\n}\n\nRestWrite.prototype.findUsersWithAuthData = function(authData) {\n  const providers = Object.keys(authData);\n  const query = providers.reduce((memo, provider) => {\n    if (!authData[provider]) {\n      return memo;\n    }\n    const queryKey = `authData.${provider}.id`;\n    const query = {};\n    query[queryKey] = authData[provider].id;\n    memo.push(query);\n    return memo;\n  }, []).filter((q) => {\n    return typeof q !== 'undefined';\n  });\n\n  let findPromise = Promise.resolve([]);\n  if (query.length > 0) {\n    findPromise = this.config.database.find(\n      this.className,\n      {'$or': query}, {})\n  }\n\n  return findPromise;\n}\n\nRestWrite.prototype.filteredObjectsByACL = function(objects) {\n  if (this.auth.isMaster) {\n    return objects;\n  }\n  return objects.filter((object) => {\n    if (!object.ACL) {\n      return true; // legacy users that have no ACL field on them\n    }\n    // Regular users that have been locked out.\n    return object.ACL && Object.keys(object.ACL).length > 0;\n  });\n}\n\nRestWrite.prototype.handleAuthData = function(authData) {\n  let results;\n  return this.findUsersWithAuthData(authData).then((r) => {\n    results = this.filteredObjectsByACL(r);\n    if (results.length > 1) {\n      // More than 1 user with the passed id's\n      throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED,\n        'this auth is already used');\n    }\n\n    this.storage['authProvider'] = Object.keys(authData).join(',');\n\n    if (results.length > 0) {\n      const userResult = results[0];\n      const mutatedAuthData = {};\n      Object.keys(authData).forEach((provider) => {\n        const providerData = authData[provider];\n        const userAuthData = userResult.authData[provider];\n        if (!_.isEqual(providerData, userAuthData)) {\n          mutatedAuthData[provider] = providerData;\n        }\n      });\n      const hasMutatedAuthData = Object.keys(mutatedAuthData).length !== 0;\n      let userId;\n      if (this.query && this.query.objectId) {\n        userId = this.query.objectId;\n      } else if (this.auth && this.auth.user && this.auth.user.id) {\n        userId = this.auth.user.id;\n      }\n      if (!userId || userId === userResult.objectId) { // no user making the call\n        // OR the user making the call is the right one\n        // Login with auth data\n        delete results[0].password;\n\n        // need to set the objectId first otherwise location has trailing undefined\n        this.data.objectId = userResult.objectId;\n\n        if (!this.query || !this.query.objectId) { // this a login call, no userId passed\n          this.response = {\n            response: userResult,\n            location: this.location()\n          };\n        }\n        // If we didn't change the auth data, just keep going\n        if (!hasMutatedAuthData) {\n          return;\n        }\n        // We have authData that is updated on login\n        // that can happen when token are refreshed,\n        // We should update the token and let the user in\n        // We should only check the mutated keys\n        return this.handleAuthDataValidation(mutatedAuthData).then(() => {\n          // IF we have a response, we'll skip the database operation / beforeSave / afterSave etc...\n          // we need to set it up there.\n          // We are supposed to have a response only on LOGIN with authData, so we skip those\n          // If we're not logging in, but just updating the current user, we can safely skip that part\n          if (this.response) {\n            // Assign the new authData in the response\n            Object.keys(mutatedAuthData).forEach((provider) => {\n              this.response.response.authData[provider] = mutatedAuthData[provider];\n            });\n            // Run the DB update directly, as 'master'\n            // Just update the authData part\n            // Then we're good for the user, early exit of sorts\n            return this.config.database.update(this.className, {objectId: this.data.objectId}, {authData: mutatedAuthData}, {});\n          }\n        });\n      } else if (userId) {\n        // Trying to update auth data but users\n        // are different\n        if (userResult.objectId !== userId) {\n          throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED,\n            'this auth is already used');\n        }\n        // No auth data was mutated, just keep going\n        if (!hasMutatedAuthData) {\n          return;\n        }\n      }\n    }\n    return this.handleAuthDataValidation(authData);\n  });\n}\n\n\n// The non-third-party parts of User transformation\nRestWrite.prototype.transformUser = function() {\n  var promise = Promise.resolve();\n\n  if (this.className !== '_User') {\n    return promise;\n  }\n\n  if (!this.auth.isMaster && \"emailVerified\" in this.data) {\n    const error = `Clients aren't allowed to manually update email verification.`\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error);\n  }\n\n  // Do not cleanup session if objectId is not set\n  if (this.query && this.objectId()) {\n    // If we're updating a _User object, we need to clear out the cache for that user. Find all their\n    // session tokens, and remove them from the cache.\n    promise = new RestQuery(this.config, Auth.master(this.config), '_Session', {\n      user: {\n        __type: \"Pointer\",\n        className: \"_User\",\n        objectId: this.objectId(),\n      }\n    }).execute()\n      .then(results => {\n        results.results.forEach(session => this.config.cacheController.user.del(session.sessionToken));\n      });\n  }\n\n  return promise.then(() => {\n    // Transform the password\n    if (this.data.password === undefined) { // ignore only if undefined. should proceed if empty ('')\n      return Promise.resolve();\n    }\n\n    if (this.query) {\n      this.storage['clearSessions'] = true;\n      // Generate a new session only if the user requested\n      if (!this.auth.isMaster) {\n        this.storage['generateNewSession'] = true;\n      }\n    }\n\n    return this._validatePasswordPolicy().then(() => {\n      return passwordCrypto.hash(this.data.password).then((hashedPassword) => {\n        this.data._hashed_password = hashedPassword;\n        delete this.data.password;\n      });\n    });\n\n  }).then(() => {\n    return this._validateUserName();\n  }).then(() => {\n    return this._validateEmail();\n  });\n};\n\nRestWrite.prototype._validateUserName = function () {\n  // Check for username uniqueness\n  if (!this.data.username) {\n    if (!this.query) {\n      this.data.username = cryptoUtils.randomString(25);\n      this.responseShouldHaveUsername = true;\n    }\n    return Promise.resolve();\n  }\n  // We need to a find to check for duplicate username in case they are missing the unique index on usernames\n  // TODO: Check if there is a unique index, and if so, skip this query.\n  return this.config.database.find(\n    this.className,\n    {username: this.data.username, objectId: {'$ne': this.objectId()}},\n    {limit: 1}\n  ).then(results => {\n    if (results.length > 0) {\n      throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');\n    }\n    return;\n  });\n};\n\nRestWrite.prototype._validateEmail = function() {\n  if (!this.data.email || this.data.email.__op === 'Delete') {\n    return Promise.resolve();\n  }\n  // Validate basic email address format\n  if (!this.data.email.match(/^.+@.+$/)) {\n    return Promise.reject(new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'Email address format is invalid.'));\n  }\n  // Same problem for email as above for username\n  return this.config.database.find(\n    this.className,\n    {email: this.data.email, objectId: {'$ne': this.objectId()}},\n    {limit: 1}\n  ).then(results => {\n    if (results.length > 0) {\n      throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');\n    }\n    if (\n      !this.data.authData ||\n      !Object.keys(this.data.authData).length ||\n      Object.keys(this.data.authData).length === 1 && Object.keys(this.data.authData)[0] === 'anonymous'\n    ) {\n      // We updated the email, send a new validation\n      this.storage['sendVerificationEmail'] = true;\n      this.config.userController.setEmailVerifyToken(this.data);\n    }\n  });\n};\n\nRestWrite.prototype._validatePasswordPolicy = function() {\n  if (!this.config.passwordPolicy)\n    return Promise.resolve();\n  return this._validatePasswordRequirements().then(() => {\n    return this._validatePasswordHistory();\n  });\n};\n\n\nRestWrite.prototype._validatePasswordRequirements = function() {\n  // check if the password conforms to the defined password policy if configured\n  const policyError = 'Password does not meet the Password Policy requirements.';\n\n  // check whether the password meets the password strength requirements\n  if (this.config.passwordPolicy.patternValidator && !this.config.passwordPolicy.patternValidator(this.data.password) ||\n    this.config.passwordPolicy.validatorCallback && !this.config.passwordPolicy.validatorCallback(this.data.password)) {\n    return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n  }\n\n  // check whether password contain username\n  if (this.config.passwordPolicy.doNotAllowUsername === true) {\n    if (this.data.username) { // username is not passed during password reset\n      if (this.data.password.indexOf(this.data.username) >= 0)\n        return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n    } else { // retrieve the User object using objectId during password reset\n      return this.config.database.find('_User', {objectId: this.objectId()})\n        .then(results => {\n          if (results.length != 1) {\n            throw undefined;\n          }\n          if (this.data.password.indexOf(results[0].username) >= 0)\n            return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, policyError));\n          return Promise.resolve();\n        });\n    }\n  }\n  return Promise.resolve();\n};\n\nRestWrite.prototype._validatePasswordHistory = function() {\n  // check whether password is repeating from specified history\n  if (this.query && this.config.passwordPolicy.maxPasswordHistory) {\n    return this.config.database.find('_User', {objectId: this.objectId()}, {keys: [\"_password_history\", \"_hashed_password\"]})\n      .then(results => {\n        if (results.length != 1) {\n          throw undefined;\n        }\n        const user = results[0];\n        let oldPasswords = [];\n        if (user._password_history)\n          oldPasswords = _.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory - 1);\n        oldPasswords.push(user.password);\n        const newPassword = this.data.password;\n        // compare the new password hash with all old password hashes\n        const promises = oldPasswords.map(function (hash) {\n          return passwordCrypto.compare(newPassword, hash).then((result) => {\n            if (result) // reject if there is a match\n              return Promise.reject(\"REPEAT_PASSWORD\");\n            return Promise.resolve();\n          })\n        });\n        // wait for all comparisons to complete\n        return Promise.all(promises).then(() => {\n          return Promise.resolve();\n        }).catch(err => {\n          if (err === \"REPEAT_PASSWORD\") // a match was found\n            return Promise.reject(new Parse.Error(Parse.Error.VALIDATION_ERROR, `New password should not be the same as last ${this.config.passwordPolicy.maxPasswordHistory} passwords.`));\n          throw err;\n        });\n      });\n  }\n  return Promise.resolve();\n};\n\nRestWrite.prototype.createSessionTokenIfNeeded = function() {\n  if (this.className !== '_User') {\n    return;\n  }\n  if (this.query) {\n    return;\n  }\n  if (!this.storage['authProvider'] // signup call, with\n      && this.config.preventLoginWithUnverifiedEmail // no login without verification\n      && this.config.verifyUserEmails) { // verification is on\n    return; // do not create the session token in that case!\n  }\n  return this.createSessionToken();\n}\n\nRestWrite.prototype.createSessionToken = function() {\n  // cloud installationId from Cloud Code,\n  // never create session tokens from there.\n  if (this.auth.installationId && this.auth.installationId === 'cloud') {\n    return;\n  }\n\n  const {\n    sessionData,\n    createSession,\n  } = Auth.createSession(this.config, {\n    userId: this.objectId(),\n    createdWith: {\n      'action': this.storage['authProvider'] ? 'login' : 'signup',\n      'authProvider': this.storage['authProvider'] || 'password'\n    },\n    installationId: this.auth.installationId,\n  });\n\n  if (this.response && this.response.response) {\n    this.response.response.sessionToken = sessionData.sessionToken;\n  }\n\n  return createSession();\n}\n\nRestWrite.prototype.destroyDuplicatedSessions = function() {\n  // Only for _Session, and at creation time\n  if (this.className != '_Session' || this.query) {\n    return;\n  }\n  // Destroy the sessions in 'Background'\n  const {\n    user,\n    installationId,\n    sessionToken,\n  } = this.data;\n  if (!user || !installationId)  {\n    return;\n  }\n  if (!user.objectId) {\n    return;\n  }\n  this.config.database.destroy('_Session', {\n    user,\n    installationId,\n    sessionToken: { '$ne': sessionToken },\n  });\n}\n\n// Handles any followup logic\nRestWrite.prototype.handleFollowup = function() {\n  if (this.storage && this.storage['clearSessions'] && this.config.revokeSessionOnPasswordReset) {\n    var sessionQuery = {\n      user: {\n        __type: 'Pointer',\n        className: '_User',\n        objectId: this.objectId()\n      }\n    };\n    delete this.storage['clearSessions'];\n    return this.config.database.destroy('_Session', sessionQuery)\n      .then(this.handleFollowup.bind(this));\n  }\n\n  if (this.storage && this.storage['generateNewSession']) {\n    delete this.storage['generateNewSession'];\n    return this.createSessionToken()\n      .then(this.handleFollowup.bind(this));\n  }\n\n  if (this.storage && this.storage['sendVerificationEmail']) {\n    delete this.storage['sendVerificationEmail'];\n    // Fire and forget!\n    this.config.userController.sendVerificationEmail(this.data);\n    return this.handleFollowup.bind(this);\n  }\n};\n\n// Handles the _Session class specialness.\n// Does nothing if this isn't an _Session object.\nRestWrite.prototype.handleSession = function() {\n  if (this.response || this.className !== '_Session') {\n    return;\n  }\n\n  if (!this.auth.user && !this.auth.isMaster) {\n    throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN,\n      'Session token required.');\n  }\n\n  // TODO: Verify proper error to throw\n  if (this.data.ACL) {\n    throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, 'Cannot set ' +\n                          'ACL on a Session.');\n  }\n\n  if (this.query) {\n    if (this.data.user && !this.auth.isMaster && this.data.user.objectId != this.auth.user.id) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    } else if (this.data.installationId) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    } else if (this.data.sessionToken) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME);\n    }\n  }\n\n  if (!this.query && !this.auth.isMaster) {\n    const additionalSessionData = {};\n    for (var key in this.data) {\n      if (key === 'objectId' || key === 'user') {\n        continue;\n      }\n      additionalSessionData[key] = this.data[key];\n    }\n\n    const { sessionData, createSession } = Auth.createSession(this.config, {\n      userId: this.auth.user.id,\n      createdWith: {\n        action: 'create',\n      },\n      additionalSessionData\n    });\n\n    return createSession().then((results) => {\n      if (!results.response) {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR,\n          'Error creating session.');\n      }\n      sessionData['objectId'] = results.response['objectId'];\n      this.response = {\n        status: 201,\n        location: results.location,\n        response: sessionData\n      };\n    });\n  }\n};\n\n// Handles the _Installation class specialness.\n// Does nothing if this isn't an installation object.\n// If an installation is found, this can mutate this.query and turn a create\n// into an update.\n// Returns a promise for when we're done if it can't finish this tick.\nRestWrite.prototype.handleInstallation = function() {\n  if (this.response || this.className !== '_Installation') {\n    return;\n  }\n\n  if (!this.query && !this.data.deviceToken && !this.data.installationId && !this.auth.installationId) {\n    throw new Parse.Error(135,\n      'at least one ID field (deviceToken, installationId) ' +\n                          'must be specified in this operation');\n  }\n\n  // If the device token is 64 characters long, we assume it is for iOS\n  // and lowercase it.\n  if (this.data.deviceToken && this.data.deviceToken.length == 64) {\n    this.data.deviceToken = this.data.deviceToken.toLowerCase();\n  }\n\n  // We lowercase the installationId if present\n  if (this.data.installationId) {\n    this.data.installationId = this.data.installationId.toLowerCase();\n  }\n\n  let installationId = this.data.installationId;\n\n  // If data.installationId is not set and we're not master, we can lookup in auth\n  if (!installationId && !this.auth.isMaster) {\n    installationId = this.auth.installationId;\n  }\n\n  if (installationId) {\n    installationId = installationId.toLowerCase();\n  }\n\n  // Updating _Installation but not updating anything critical\n  if (this.query && !this.data.deviceToken\n                  && !installationId && !this.data.deviceType) {\n    return;\n  }\n\n  var promise = Promise.resolve();\n\n  var idMatch; // Will be a match on either objectId or installationId\n  var objectIdMatch;\n  var installationIdMatch;\n  var deviceTokenMatches = [];\n\n  // Instead of issuing 3 reads, let's do it with one OR.\n  const orQueries = [];\n  if (this.query && this.query.objectId) {\n    orQueries.push({\n      objectId: this.query.objectId\n    });\n  }\n  if (installationId) {\n    orQueries.push({\n      'installationId': installationId\n    });\n  }\n  if (this.data.deviceToken) {\n    orQueries.push({'deviceToken': this.data.deviceToken});\n  }\n\n  if (orQueries.length == 0) {\n    return;\n  }\n\n  promise = promise.then(() => {\n    return this.config.database.find('_Installation', {\n      '$or': orQueries\n    }, {});\n  }).then((results) => {\n    results.forEach((result) => {\n      if (this.query && this.query.objectId && result.objectId == this.query.objectId) {\n        objectIdMatch = result;\n      }\n      if (result.installationId == installationId) {\n        installationIdMatch = result;\n      }\n      if (result.deviceToken == this.data.deviceToken) {\n        deviceTokenMatches.push(result);\n      }\n    });\n\n    // Sanity checks when running a query\n    if (this.query && this.query.objectId) {\n      if (!objectIdMatch) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n          'Object not found for update.');\n      }\n      if (this.data.installationId && objectIdMatch.installationId &&\n          this.data.installationId !== objectIdMatch.installationId) {\n        throw new Parse.Error(136,\n          'installationId may not be changed in this ' +\n                                'operation');\n      }\n      if (this.data.deviceToken && objectIdMatch.deviceToken &&\n          this.data.deviceToken !== objectIdMatch.deviceToken &&\n          !this.data.installationId && !objectIdMatch.installationId) {\n        throw new Parse.Error(136,\n          'deviceToken may not be changed in this ' +\n                                'operation');\n      }\n      if (this.data.deviceType && this.data.deviceType &&\n          this.data.deviceType !== objectIdMatch.deviceType) {\n        throw new Parse.Error(136,\n          'deviceType may not be changed in this ' +\n                                'operation');\n      }\n    }\n\n    if (this.query && this.query.objectId && objectIdMatch) {\n      idMatch = objectIdMatch;\n    }\n\n    if (installationId && installationIdMatch) {\n      idMatch = installationIdMatch;\n    }\n    // need to specify deviceType only if it's new\n    if (!this.query && !this.data.deviceType && !idMatch) {\n      throw new Parse.Error(135,\n        'deviceType must be specified in this operation');\n    }\n\n  }).then(() => {\n    if (!idMatch) {\n      if (!deviceTokenMatches.length) {\n        return;\n      } else if (deviceTokenMatches.length == 1 &&\n        (!deviceTokenMatches[0]['installationId'] || !installationId)\n      ) {\n        // Single match on device token but none on installationId, and either\n        // the passed object or the match is missing an installationId, so we\n        // can just return the match.\n        return deviceTokenMatches[0]['objectId'];\n      } else if (!this.data.installationId) {\n        throw new Parse.Error(132,\n          'Must specify installationId when deviceToken ' +\n                              'matches multiple Installation objects');\n      } else {\n        // Multiple device token matches and we specified an installation ID,\n        // or a single match where both the passed and matching objects have\n        // an installation ID. Try cleaning out old installations that match\n        // the deviceToken, and return nil to signal that a new object should\n        // be created.\n        var delQuery = {\n          'deviceToken': this.data.deviceToken,\n          'installationId': {\n            '$ne': installationId\n          }\n        };\n        if (this.data.appIdentifier) {\n          delQuery['appIdentifier'] = this.data.appIdentifier;\n        }\n        this.config.database.destroy('_Installation', delQuery)\n          .catch(err => {\n            if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n              // no deletions were made. Can be ignored.\n              return;\n            }\n            // rethrow the error\n            throw err;\n          });\n        return;\n      }\n    } else {\n      if (deviceTokenMatches.length == 1 &&\n        !deviceTokenMatches[0]['installationId']) {\n        // Exactly one device token match and it doesn't have an installation\n        // ID. This is the one case where we want to merge with the existing\n        // object.\n        const delQuery = {objectId: idMatch.objectId};\n        return this.config.database.destroy('_Installation', delQuery)\n          .then(() => {\n            return deviceTokenMatches[0]['objectId'];\n          })\n          .catch(err => {\n            if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n              // no deletions were made. Can be ignored\n              return;\n            }\n            // rethrow the error\n            throw err;\n          });\n      } else {\n        if (this.data.deviceToken &&\n          idMatch.deviceToken != this.data.deviceToken) {\n          // We're setting the device token on an existing installation, so\n          // we should try cleaning out old installations that match this\n          // device token.\n          const delQuery = {\n            'deviceToken': this.data.deviceToken,\n          };\n          // We have a unique install Id, use that to preserve\n          // the interesting installation\n          if (this.data.installationId) {\n            delQuery['installationId'] = {\n              '$ne': this.data.installationId\n            }\n          } else if (idMatch.objectId && this.data.objectId\n                    && idMatch.objectId == this.data.objectId) {\n            // we passed an objectId, preserve that instalation\n            delQuery['objectId'] = {\n              '$ne': idMatch.objectId\n            }\n          } else {\n            // What to do here? can't really clean up everything...\n            return idMatch.objectId;\n          }\n          if (this.data.appIdentifier) {\n            delQuery['appIdentifier'] = this.data.appIdentifier;\n          }\n          this.config.database.destroy('_Installation', delQuery)\n            .catch(err => {\n              if (err.code == Parse.Error.OBJECT_NOT_FOUND) {\n                // no deletions were made. Can be ignored.\n                return;\n              }\n              // rethrow the error\n              throw err;\n            });\n        }\n        // In non-merge scenarios, just return the installation match id\n        return idMatch.objectId;\n      }\n    }\n  }).then((objId) => {\n    if (objId) {\n      this.query = {objectId: objId};\n      delete this.data.objectId;\n      delete this.data.createdAt;\n    }\n    // TODO: Validate ops (add/remove on channels, $inc on badge, etc.)\n  });\n  return promise;\n};\n\n// If we short-circuted the object response - then we need to make sure we expand all the files,\n// since this might not have a query, meaning it won't return the full result back.\n// TODO: (nlutsenko) This should die when we move to per-class based controllers on _Session/_User\nRestWrite.prototype.expandFilesForExistingObjects = function() {\n  // Check whether we have a short-circuited response - only then run expansion.\n  if (this.response && this.response.response) {\n    this.config.filesController.expandFilesInObject(this.config, this.response.response);\n  }\n};\n\nRestWrite.prototype.runDatabaseOperation = function() {\n  if (this.response) {\n    return;\n  }\n\n  if (this.className === '_Role') {\n    this.config.cacheController.role.clear();\n  }\n\n  if (this.className === '_User' &&\n      this.query &&\n      this.auth.isUnauthenticated()) {\n    throw new Parse.Error(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`);\n  }\n\n  if (this.className === '_Product' && this.data.download) {\n    this.data.downloadName = this.data.download.name;\n  }\n\n  // TODO: Add better detection for ACL, ensuring a user can't be locked from\n  //       their own user record.\n  if (this.data.ACL && this.data.ACL['*unresolved']) {\n    throw new Parse.Error(Parse.Error.INVALID_ACL, 'Invalid ACL.');\n  }\n\n  if (this.query) {\n    // Force the user to not lockout\n    // Matched with parse.com\n    if (this.className === '_User' && this.data.ACL && this.auth.isMaster !== true) {\n      this.data.ACL[this.query.objectId] = { read: true, write: true };\n    }\n    // update password timestamp if user password is being changed\n    if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {\n      this.data._password_changed_at = Parse._encode(new Date());\n    }\n    // Ignore createdAt when update\n    delete this.data.createdAt;\n\n    let defer = Promise.resolve();\n    // if password history is enabled then save the current password to history\n    if (this.className === '_User' && this.data._hashed_password && this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordHistory) {\n      defer = this.config.database.find('_User', {objectId: this.objectId()}, {keys: [\"_password_history\", \"_hashed_password\"]}).then(results => {\n        if (results.length != 1) {\n          throw undefined;\n        }\n        const user = results[0];\n        let oldPasswords = [];\n        if (user._password_history) {\n          oldPasswords = _.take(user._password_history, this.config.passwordPolicy.maxPasswordHistory);\n        }\n        //n-1 passwords go into history including last password\n        while (oldPasswords.length > this.config.passwordPolicy.maxPasswordHistory - 2) {\n          oldPasswords.shift();\n        }\n        oldPasswords.push(user.password);\n        this.data._password_history = oldPasswords;\n      });\n    }\n\n    return defer.then(() => {\n      // Run an update\n      return this.config.database.update(this.className, this.query, this.data, this.runOptions)\n        .then(response => {\n          response.updatedAt = this.updatedAt;\n          this._updateResponseWithData(response, this.data);\n          this.response = { response };\n        });\n    });\n  } else {\n    // Set the default ACL and password timestamp for the new _User\n    if (this.className === '_User') {\n      var ACL = this.data.ACL;\n      // default public r/w ACL\n      if (!ACL) {\n        ACL = {};\n        ACL['*'] = { read: true, write: false };\n      }\n      // make sure the user is not locked down\n      ACL[this.data.objectId] = { read: true, write: true };\n      this.data.ACL = ACL;\n      // password timestamp to be used when password expiry policy is enforced\n      if (this.config.passwordPolicy && this.config.passwordPolicy.maxPasswordAge) {\n        this.data._password_changed_at = Parse._encode(new Date());\n      }\n    }\n\n    // Run a create\n    return this.config.database.create(this.className, this.data, this.runOptions)\n      .catch(error => {\n        if (this.className !== '_User' || error.code !== Parse.Error.DUPLICATE_VALUE) {\n          throw error;\n        }\n\n        // Quick check, if we were able to infer the duplicated field name\n        if (error && error.userInfo && error.userInfo.duplicated_field === 'username') {\n          throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');\n        }\n\n        if (error && error.userInfo && error.userInfo.duplicated_field === 'email') {\n          throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');\n        }\n\n        // If this was a failed user creation due to username or email already taken, we need to\n        // check whether it was username or email and return the appropriate error.\n        // Fallback to the original method\n        // TODO: See if we can later do this without additional queries by using named indexes.\n        return this.config.database.find(\n          this.className,\n          { username: this.data.username, objectId: {'$ne': this.objectId()} },\n          { limit: 1 }\n        )\n          .then(results => {\n            if (results.length > 0) {\n              throw new Parse.Error(Parse.Error.USERNAME_TAKEN, 'Account already exists for this username.');\n            }\n            return this.config.database.find(\n              this.className,\n              { email: this.data.email, objectId: {'$ne': this.objectId()} },\n              { limit: 1 }\n            );\n          })\n          .then(results => {\n            if (results.length > 0) {\n              throw new Parse.Error(Parse.Error.EMAIL_TAKEN, 'Account already exists for this email address.');\n            }\n            throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          });\n      })\n      .then(response => {\n        response.objectId = this.data.objectId;\n        response.createdAt = this.data.createdAt;\n\n        if (this.responseShouldHaveUsername) {\n          response.username = this.data.username;\n        }\n        this._updateResponseWithData(response, this.data);\n        this.response = {\n          status: 201,\n          response,\n          location: this.location()\n        };\n      });\n  }\n};\n\n// Returns nothing - doesn't wait for the trigger.\nRestWrite.prototype.runAfterTrigger = function() {\n  if (!this.response || !this.response.response) {\n    return;\n  }\n\n  // Avoid doing any setup for triggers if there is no 'afterSave' trigger for this class.\n  const hasAfterSaveHook = triggers.triggerExists(this.className, triggers.Types.afterSave, this.config.applicationId);\n  const hasLiveQuery = this.config.liveQueryController.hasLiveQuery(this.className);\n  if (!hasAfterSaveHook && !hasLiveQuery) {\n    return Promise.resolve();\n  }\n\n  var extraData = {className: this.className};\n  if (this.query && this.query.objectId) {\n    extraData.objectId = this.query.objectId;\n  }\n\n  // Build the original object, we only do this for a update write.\n  let originalObject;\n  if (this.query && this.query.objectId) {\n    originalObject = triggers.inflate(extraData, this.originalData);\n  }\n\n  // Build the inflated object, different from beforeSave, originalData is not empty\n  // since developers can change data in the beforeSave.\n  const updatedObject = this.buildUpdatedObject(extraData);\n  updatedObject._handleSaveResponse(this.response.response, this.response.status || 200);\n\n  // Notifiy LiveQueryServer if possible\n  this.config.liveQueryController.onAfterSave(updatedObject.className, updatedObject, originalObject);\n\n  // Run afterSave trigger\n  return triggers.maybeRunTrigger(triggers.Types.afterSave, this.auth, updatedObject, originalObject, this.config)\n    .catch(function(err) {\n      logger.warn('afterSave caught an error', err);\n    })\n};\n\n// A helper to figure out what location this operation happens at.\nRestWrite.prototype.location = function() {\n  var middle = (this.className === '_User' ? '/users/' :\n    '/classes/' + this.className + '/');\n  return this.config.mount + middle + this.data.objectId;\n};\n\n// A helper to get the object id for this operation.\n// Because it could be either on the query or on the data\nRestWrite.prototype.objectId = function() {\n  return this.data.objectId || this.query.objectId;\n};\n\n// Returns a copy of the data and delete bad keys (_auth_data, _hashed_password...)\nRestWrite.prototype.sanitizedData = function() {\n  const data = Object.keys(this.data).reduce((data, key) => {\n    // Regexp comes from Parse.Object.prototype.validate\n    if (!(/^[A-Za-z][0-9A-Za-z_]*$/).test(key)) {\n      delete data[key];\n    }\n    return data;\n  }, deepcopy(this.data));\n  return Parse._decode(undefined, data);\n}\n\n// Returns an updated copy of the object\nRestWrite.prototype.buildUpdatedObject = function (extraData) {\n  const updatedObject = triggers.inflate(extraData, this.originalData);\n  Object.keys(this.data).reduce(function (data, key) {\n    if (key.indexOf(\".\") > 0) {\n      // subdocument key with dot notation ('x.y':v => 'x':{'y':v})\n      const splittedKey = key.split(\".\");\n      const parentProp = splittedKey[0];\n      let parentVal = updatedObject.get(parentProp);\n      if(typeof parentVal !== 'object') {\n        parentVal = {};\n      }\n      parentVal[splittedKey[1]] = data[key];\n      updatedObject.set(parentProp, parentVal);\n      delete data[key];\n    }\n    return data;\n  }, deepcopy(this.data));\n\n  updatedObject.set(this.sanitizedData());\n  return updatedObject;\n};\n\nRestWrite.prototype.cleanUserAuthData = function() {\n  if (this.response && this.response.response && this.className === '_User') {\n    const user = this.response.response;\n    if (user.authData) {\n      Object.keys(user.authData).forEach((provider) => {\n        if (user.authData[provider] === null) {\n          delete user.authData[provider];\n        }\n      });\n      if (Object.keys(user.authData).length == 0) {\n        delete user.authData;\n      }\n    }\n  }\n};\n\nRestWrite.prototype._updateResponseWithData = function(response, data) {\n  if (_.isEmpty(this.storage.fieldsChangedByTrigger)) {\n    return response;\n  }\n  const clientSupportsDelete = ClientSDK.supportsForwardDelete(this.clientSDK);\n  this.storage.fieldsChangedByTrigger.forEach(fieldName => {\n    const dataValue = data[fieldName];\n\n    if(!response.hasOwnProperty(fieldName)) {\n      response[fieldName] = dataValue;\n    }\n\n    // Strips operations from responses\n    if (response[fieldName] && response[fieldName].__op) {\n      delete response[fieldName];\n      if (clientSupportsDelete && dataValue.__op == 'Delete') {\n        response[fieldName] = dataValue;\n      }\n    }\n  });\n  return response;\n}\n\nexport default RestWrite;\nmodule.exports = RestWrite;\n"]} \ No newline at end of file diff --git a/lib/Routers/AggregateRouter.js b/lib/Routers/AggregateRouter.js index 2a0519915e..367604e6ab 100644 --- a/lib/Routers/AggregateRouter.js +++ b/lib/Routers/AggregateRouter.js @@ -29,30 +29,30 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -const ALLOWED_KEYS = ['where', 'distinct', 'project', 'match', 'redact', 'limit', 'skip', 'unwind', 'group', 'sample', 'sort', 'geoNear', 'lookup', 'out', 'indexStats', 'facet', 'bucket', 'bucketAuto', 'sortByCount', 'addFields', 'replaceRoot', 'count', 'graphLookup']; +const BASE_KEYS = ['where', 'distinct']; + +const PIPELINE_KEYS = ['addFields', 'bucket', 'bucketAuto', 'collStats', 'count', 'currentOp', 'facet', 'geoNear', 'graphLookup', 'group', 'indexStats', 'limit', 'listLocalSessions', 'listSessions', 'lookup', 'match', 'out', 'project', 'redact', 'replaceRoot', 'sample', 'skip', 'sort', 'sortByCount', 'unwind']; + +const ALLOWED_KEYS = [...BASE_KEYS, ...PIPELINE_KEYS]; class AggregateRouter extends _ClassesRouter2.default { handleFind(req) { const body = Object.assign(req.body, _ClassesRouter2.default.JSONFromQuery(req.query)); const options = {}; - const pipeline = []; - - for (const key in body) { - if (ALLOWED_KEYS.indexOf(key) === -1) { - throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: ${key}`); - } - if (key === 'group') { - if (body[key].hasOwnProperty('_id')) { - throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: group. Please use objectId instead of _id`); - } - if (!body[key].hasOwnProperty('objectId')) { - throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: group. objectId is required`); - } - body[key]._id = body[key].objectId; - delete body[key].objectId; + let pipeline = []; + + if (Array.isArray(body)) { + pipeline = body.map(stage => { + const stageName = Object.keys(stage)[0]; + return this.transformStage(stageName, stage); + }); + } else { + const stages = []; + for (const stageName in body) { + stages.push(this.transformStage(stageName, body)); } - pipeline.push({ [`$${key}`]: body[key] }); + pipeline = stages; } if (body.distinct) { options.distinct = String(body.distinct); @@ -71,6 +71,23 @@ class AggregateRouter extends _ClassesRouter2.default { }); } + transformStage(stageName, stage) { + if (ALLOWED_KEYS.indexOf(stageName) === -1) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: ${stageName}`); + } + if (stageName === 'group') { + if (stage[stageName].hasOwnProperty('_id')) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: group. Please use objectId instead of _id`); + } + if (!stage[stageName].hasOwnProperty('objectId')) { + throw new _node2.default.Error(_node2.default.Error.INVALID_QUERY, `Invalid parameter for query: group. objectId is required`); + } + stage[stageName]._id = stage[stageName].objectId; + delete stage[stageName].objectId; + } + return { [`$${stageName}`]: stage[stageName] }; + } + mountRoutes() { this.route('GET', '/aggregate/:className', middleware.promiseEnforceMasterKeyAccess, req => { return this.handleFind(req); @@ -79,4 +96,5 @@ class AggregateRouter extends _ClassesRouter2.default { } exports.AggregateRouter = AggregateRouter; -exports.default = AggregateRouter; \ No newline at end of file +exports.default = AggregateRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/AggregateRouter.js"],"names":["middleware","BASE_KEYS","PIPELINE_KEYS","ALLOWED_KEYS","AggregateRouter","ClassesRouter","handleFind","req","body","Object","assign","JSONFromQuery","query","options","pipeline","Array","isArray","map","stage","stageName","keys","transformStage","stages","push","distinct","String","where","JSON","parse","rest","find","config","auth","className","info","clientSDK","then","response","result","results","UsersRouter","removeHiddenProperties","indexOf","Parse","Error","INVALID_QUERY","hasOwnProperty","_id","objectId","mountRoutes","route","promiseEnforceMasterKeyAccess"],"mappings":"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","file":"AggregateRouter.js","sourcesContent":["import ClassesRouter from './ClassesRouter';\nimport rest from '../rest';\nimport * as middleware from '../middlewares';\nimport Parse         from 'parse/node';\nimport UsersRouter   from './UsersRouter';\n\nconst BASE_KEYS = ['where', 'distinct'];\n\nconst PIPELINE_KEYS = [\n  'addFields',\n  'bucket',\n  'bucketAuto',\n  'collStats',\n  'count',\n  'currentOp',\n  'facet',\n  'geoNear',\n  'graphLookup',\n  'group',\n  'indexStats',\n  'limit',\n  'listLocalSessions',\n  'listSessions',\n  'lookup',\n  'match',\n  'out',\n  'project',\n  'redact',\n  'replaceRoot',\n  'sample',\n  'skip',\n  'sort',\n  'sortByCount',\n  'unwind',\n];\n\nconst ALLOWED_KEYS = [...BASE_KEYS, ...PIPELINE_KEYS];\n\nexport class AggregateRouter extends ClassesRouter {\n\n  handleFind(req) {\n    const body = Object.assign(req.body, ClassesRouter.JSONFromQuery(req.query));\n    const options = {};\n    let pipeline = [];\n\n    if (Array.isArray(body)) {\n      pipeline = body.map((stage) => {\n        const stageName = Object.keys(stage)[0];\n        return this.transformStage(stageName, stage);\n      });\n    } else {\n      const stages = [];\n      for (const stageName in body) {\n        stages.push(this.transformStage(stageName, body));\n      }\n      pipeline = stages;\n    }\n    if (body.distinct) {\n      options.distinct = String(body.distinct);\n    }\n    options.pipeline = pipeline;\n    if (typeof body.where === 'string') {\n      body.where = JSON.parse(body.where);\n    }\n    return rest.find(req.config, req.auth, this.className(req), body.where, options, req.info.clientSDK).then((response) => {\n      for(const result of response.results) {\n        if(typeof result === 'object') {\n          UsersRouter.removeHiddenProperties(result);\n        }\n      }\n      return { response };\n    });\n  }\n\n  transformStage(stageName, stage) {\n    if (ALLOWED_KEYS.indexOf(stageName) === -1) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_QUERY,\n        `Invalid parameter for query: ${stageName}`\n      );\n    }\n    if (stageName === 'group') {\n      if (stage[stageName].hasOwnProperty('_id')) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_QUERY,\n          `Invalid parameter for query: group. Please use objectId instead of _id`\n        );\n      }\n      if (!stage[stageName].hasOwnProperty('objectId')) {\n        throw new Parse.Error(\n          Parse.Error.INVALID_QUERY,\n          `Invalid parameter for query: group. objectId is required`\n        );\n      }\n      stage[stageName]._id = stage[stageName].objectId;\n      delete stage[stageName].objectId;\n    }\n    return { [`$${stageName}`]: stage[stageName] };\n  }\n\n  mountRoutes() {\n    this.route('GET','/aggregate/:className', middleware.promiseEnforceMasterKeyAccess, req => { return this.handleFind(req); });\n  }\n}\n\nexport default AggregateRouter;\n"]} \ No newline at end of file diff --git a/lib/Routers/AnalyticsRouter.js b/lib/Routers/AnalyticsRouter.js index 4cd6885171..6a74dd685e 100644 --- a/lib/Routers/AnalyticsRouter.js +++ b/lib/Routers/AnalyticsRouter.js @@ -28,4 +28,5 @@ class AnalyticsRouter extends _PromiseRouter2.default { this.route('POST', '/events/:eventName', trackEvent); } } -exports.AnalyticsRouter = AnalyticsRouter; \ No newline at end of file +exports.AnalyticsRouter = AnalyticsRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9Sb3V0ZXJzL0FuYWx5dGljc1JvdXRlci5qcyJdLCJuYW1lcyI6WyJhcHBPcGVuZWQiLCJyZXEiLCJhbmFseXRpY3NDb250cm9sbGVyIiwiY29uZmlnIiwidHJhY2tFdmVudCIsIkFuYWx5dGljc1JvdXRlciIsIlByb21pc2VSb3V0ZXIiLCJtb3VudFJvdXRlcyIsInJvdXRlIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBQ0E7Ozs7OztBQUVBLFNBQVNBLFNBQVQsQ0FBbUJDLEdBQW5CLEVBQXdCO0FBQ3RCLFFBQU1DLHNCQUFzQkQsSUFBSUUsTUFBSixDQUFXRCxtQkFBdkM7QUFDQSxTQUFPQSxvQkFBb0JGLFNBQXBCLENBQThCQyxHQUE5QixDQUFQO0FBQ0QsQyxDQU5EOzs7QUFRQSxTQUFTRyxVQUFULENBQW9CSCxHQUFwQixFQUF5QjtBQUN2QixRQUFNQyxzQkFBc0JELElBQUlFLE1BQUosQ0FBV0QsbUJBQXZDO0FBQ0EsU0FBT0Esb0JBQW9CRSxVQUFwQixDQUErQkgsR0FBL0IsQ0FBUDtBQUNEOztBQUdNLE1BQU1JLGVBQU4sU0FBOEJDLHVCQUE5QixDQUE0QztBQUNqREMsZ0JBQWM7QUFDWixTQUFLQyxLQUFMLENBQVcsTUFBWCxFQUFrQixtQkFBbEIsRUFBdUNSLFNBQXZDO0FBQ0EsU0FBS1EsS0FBTCxDQUFXLE1BQVgsRUFBa0Isb0JBQWxCLEVBQXdDSixVQUF4QztBQUNEO0FBSmdEO1FBQXRDQyxlLEdBQUFBLGUiLCJmaWxlIjoiQW5hbHl0aWNzUm91dGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQW5hbHl0aWNzUm91dGVyLmpzXG5pbXBvcnQgUHJvbWlzZVJvdXRlciBmcm9tICcuLi9Qcm9taXNlUm91dGVyJztcblxuZnVuY3Rpb24gYXBwT3BlbmVkKHJlcSkge1xuICBjb25zdCBhbmFseXRpY3NDb250cm9sbGVyID0gcmVxLmNvbmZpZy5hbmFseXRpY3NDb250cm9sbGVyO1xuICByZXR1cm4gYW5hbHl0aWNzQ29udHJvbGxlci5hcHBPcGVuZWQocmVxKTtcbn1cblxuZnVuY3Rpb24gdHJhY2tFdmVudChyZXEpIHtcbiAgY29uc3QgYW5hbHl0aWNzQ29udHJvbGxlciA9IHJlcS5jb25maWcuYW5hbHl0aWNzQ29udHJvbGxlcjtcbiAgcmV0dXJuIGFuYWx5dGljc0NvbnRyb2xsZXIudHJhY2tFdmVudChyZXEpO1xufVxuXG5cbmV4cG9ydCBjbGFzcyBBbmFseXRpY3NSb3V0ZXIgZXh0ZW5kcyBQcm9taXNlUm91dGVyIHtcbiAgbW91bnRSb3V0ZXMoKSB7XG4gICAgdGhpcy5yb3V0ZSgnUE9TVCcsJy9ldmVudHMvQXBwT3BlbmVkJywgYXBwT3BlbmVkKTtcbiAgICB0aGlzLnJvdXRlKCdQT1NUJywnL2V2ZW50cy86ZXZlbnROYW1lJywgdHJhY2tFdmVudCk7XG4gIH1cbn1cbiJdfQ== \ No newline at end of file diff --git a/lib/Routers/AudiencesRouter.js b/lib/Routers/AudiencesRouter.js index ce31014ea5..2a1bee314a 100644 --- a/lib/Routers/AudiencesRouter.js +++ b/lib/Routers/AudiencesRouter.js @@ -69,4 +69,5 @@ class AudiencesRouter extends _ClassesRouter2.default { } exports.AudiencesRouter = AudiencesRouter; -exports.default = AudiencesRouter; \ No newline at end of file +exports.default = AudiencesRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/ClassesRouter.js b/lib/Routers/ClassesRouter.js index d038344e8b..cec5df38d3 100644 --- a/lib/Routers/ClassesRouter.js +++ b/lib/Routers/ClassesRouter.js @@ -115,7 +115,7 @@ class ClassesRouter extends _PromiseRouter2.default { } static optionsFromBody(body) { - const allowConstraints = ['skip', 'limit', 'order', 'count', 'keys', 'include', 'redirectClassNameForKey', 'where']; + const allowConstraints = ['skip', 'limit', 'order', 'count', 'keys', 'include', 'includeAll', 'redirectClassNameForKey', 'where']; for (const key of Object.keys(body)) { if (allowConstraints.indexOf(key) === -1) { @@ -143,6 +143,9 @@ class ClassesRouter extends _PromiseRouter2.default { if (body.include) { options.include = String(body.include); } + if (body.includeAll) { + options.includeAll = true; + } return options; } @@ -166,4 +169,5 @@ class ClassesRouter extends _PromiseRouter2.default { } exports.ClassesRouter = ClassesRouter; -exports.default = ClassesRouter; \ No newline at end of file +exports.default = ClassesRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/ClassesRouter.js"],"names":["ALLOWED_GET_QUERY_KEYS","ClassesRouter","PromiseRouter","className","req","params","handleFind","body","Object","assign","JSONFromQuery","query","options","optionsFromBody","config","maxLimit","limit","Number","redirectClassNameForKey","String","where","JSON","parse","rest","find","auth","info","clientSDK","then","response","handleGet","key","keys","indexOf","Parse","Error","INVALID_QUERY","include","get","objectId","results","length","OBJECT_NOT_FOUND","sessionToken","user","id","handleCreate","create","handleUpdate","update","handleDelete","del","json","value","_","entries","e","allowConstraints","skip","order","count","includeAll","mountRoutes","route"],"mappings":"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","file":"ClassesRouter.js","sourcesContent":["\nimport PromiseRouter from '../PromiseRouter';\nimport rest          from '../rest';\nimport _             from 'lodash';\nimport Parse         from 'parse/node';\n\nconst ALLOWED_GET_QUERY_KEYS = ['keys', 'include'];\n\nexport class ClassesRouter extends PromiseRouter {\n\n  className(req) {\n    return req.params.className;\n  }\n\n  handleFind(req) {\n    const body = Object.assign(req.body, ClassesRouter.JSONFromQuery(req.query));\n    const options = ClassesRouter.optionsFromBody(body);\n    if (req.config.maxLimit && (body.limit > req.config.maxLimit)) {\n      // Silently replace the limit on the query with the max configured\n      options.limit = Number(req.config.maxLimit);\n    }\n    if (body.redirectClassNameForKey) {\n      options.redirectClassNameForKey = String(body.redirectClassNameForKey);\n    }\n    if (typeof body.where === 'string') {\n      body.where = JSON.parse(body.where);\n    }\n    return rest.find(req.config, req.auth, this.className(req), body.where, options, req.info.clientSDK)\n      .then((response) => {\n        return { response: response };\n      });\n  }\n\n  // Returns a promise for a {response} object.\n  handleGet(req) {\n    const body = Object.assign(req.body, ClassesRouter.JSONFromQuery(req.query));\n    const options = {};\n\n    for (const key of Object.keys(body)) {\n      if (ALLOWED_GET_QUERY_KEYS.indexOf(key) === -1) {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Improper encode of parameter');\n      }\n    }\n\n    if (typeof body.keys == 'string') {\n      options.keys = body.keys;\n    }\n    if (body.include) {\n      options.include = String(body.include);\n    }\n\n    return rest.get(req.config, req.auth, this.className(req), req.params.objectId, options, req.info.clientSDK)\n      .then((response) => {\n        if (!response.results || response.results.length == 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n\n        if (this.className(req) === \"_User\") {\n\n          delete response.results[0].sessionToken;\n\n          const user =  response.results[0];\n\n          if (req.auth.user && user.objectId == req.auth.user.id) {\n            // Force the session token\n            response.results[0].sessionToken = req.info.sessionToken;\n          }\n        }\n        return { response: response.results[0] };\n      });\n  }\n\n  handleCreate(req) {\n    return rest.create(req.config, req.auth, this.className(req), req.body, req.info.clientSDK);\n  }\n\n  handleUpdate(req) {\n    const where = { objectId: req.params.objectId }\n    return rest.update(req.config, req.auth, this.className(req), where, req.body, req.info.clientSDK);\n  }\n\n  handleDelete(req) {\n    return rest.del(req.config, req.auth, this.className(req), req.params.objectId, req.info.clientSDK)\n      .then(() => {\n        return {response: {}};\n      });\n  }\n\n  static JSONFromQuery(query) {\n    const json = {};\n    for (const [key, value] of _.entries(query)) {\n      try {\n        json[key] = JSON.parse(value);\n      } catch (e) {\n        json[key] = value;\n      }\n    }\n    return json\n  }\n\n  static optionsFromBody(body) {\n    const allowConstraints = ['skip', 'limit', 'order', 'count', 'keys',\n      'include', 'includeAll', 'redirectClassNameForKey', 'where'];\n\n    for (const key of Object.keys(body)) {\n      if (allowConstraints.indexOf(key) === -1) {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Invalid parameter for query: ${key}`);\n      }\n    }\n    const options = {};\n    if (body.skip) {\n      options.skip = Number(body.skip);\n    }\n    if (body.limit || body.limit === 0) {\n      options.limit = Number(body.limit);\n    } else {\n      options.limit = Number(100);\n    }\n    if (body.order) {\n      options.order = String(body.order);\n    }\n    if (body.count) {\n      options.count = true;\n    }\n    if (typeof body.keys == 'string') {\n      options.keys = body.keys;\n    }\n    if (body.include) {\n      options.include = String(body.include);\n    }\n    if (body.includeAll) {\n      options.includeAll = true;\n    }\n    return options;\n  }\n\n  mountRoutes() {\n    this.route('GET', '/classes/:className', (req) => { return this.handleFind(req); });\n    this.route('GET', '/classes/:className/:objectId', (req) => { return this.handleGet(req); });\n    this.route('POST', '/classes/:className', (req) => { return this.handleCreate(req); });\n    this.route('PUT', '/classes/:className/:objectId', (req) => { return this.handleUpdate(req); });\n    this.route('DELETE',  '/classes/:className/:objectId', (req) => { return this.handleDelete(req); });\n  }\n}\n\nexport default ClassesRouter;\n"]} \ No newline at end of file diff --git a/lib/Routers/CloudCodeRouter.js b/lib/Routers/CloudCodeRouter.js index 69ff4066e4..5fb235b0c1 100644 --- a/lib/Routers/CloudCodeRouter.js +++ b/lib/Routers/CloudCodeRouter.js @@ -92,4 +92,5 @@ class CloudCodeRouter extends _PromiseRouter2.default { }); } } -exports.CloudCodeRouter = CloudCodeRouter; \ No newline at end of file +exports.CloudCodeRouter = CloudCodeRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/ExportRouter.js b/lib/Routers/ExportRouter.js index 0e834ae1e4..0645dc9841 100644 --- a/lib/Routers/ExportRouter.js +++ b/lib/Routers/ExportRouter.js @@ -209,4 +209,5 @@ class ExportRouter extends _PromiseRouter2.default { } exports.ExportRouter = ExportRouter; -exports.default = ExportRouter; \ No newline at end of file +exports.default = ExportRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/ExportRouter.js"],"names":["DefaultExportExportProgressCollectionName","relationSchema","fields","relatedId","type","owningId","ExportRouter","PromiseRouter","exportClassPage","req","name","jsonFileStream","where","skip","limit","databaseController","config","database","options","findPromise","indexOf","adapter","find","rest","auth","then","data","Array","isArray","results","length","write","JSON","stringify","substr","slice","exportClass","tmpJsonFile","tmp","fileSync","fs","createWriteStream","count","result","Number","isInteger","i","pageLimit","promise","Promise","resolve","end","on","_name","replace","handleExportProgress","query","masterKey","info","applicationId","appId","response","handleExport","emailControllerAdapter","emailAdapter","reject","Error","exportProgress","id","body","create","loadSchema","clearCache","schemaController","getOneSchema","schema","classNames","Object","keys","forEach","fieldName","field","push","promisses","map","all","jsonFiles","tmpZipFile","tmpZipStream","zip","pipe","append","readFileSync","removeCallback","finalize","buf","zippedFile","filesController","createFile","fileData","sendMail","text","url","link","to","feedbackEmail","subject","catch","error","destroy","mountRoutes","route"],"mappings":"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","file":"ExportRouter.js","sourcesContent":["import PromiseRouter   from '../PromiseRouter';\nimport { loadAdapter } from '../Adapters/AdapterLoader';\nimport rest            from '../rest';\nimport archiver        from 'archiver';\nimport tmp             from 'tmp';\nimport fs from 'fs';\n\nconst DefaultExportExportProgressCollectionName = \"_ExportProgress\";\nconst relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } };\n\nexport class ExportRouter extends PromiseRouter {\n\n  exportClassPage(req, name, jsonFileStream, where, skip, limit) {\n\n    const databaseController = req.config.database;\n\n    const options =  {\n      skip,\n      limit\n    };\n\n    const findPromise = name.indexOf('_Join') === 0 ?\n      databaseController.adapter.find(name, relationSchema, where, options)\n      : rest.find(req.config, req.auth, name,  where, options);\n\n    return findPromise\n      .then((data) => {\n        if (Array.isArray(data)) {\n          data = { results : data };\n        }\n\n        if (skip && data.results.length) {\n          jsonFileStream.write(',\\n');\n        }\n\n        jsonFileStream.write(JSON.stringify(data.results, null, 2).substr(1).slice(0,-1));\n      });\n  }\n\n  exportClass(req, data) {\n\n\n    const databaseController = req.config.database;\n    const tmpJsonFile = tmp.fileSync();\n    const jsonFileStream = fs.createWriteStream(tmpJsonFile.name);\n\n    jsonFileStream.write('{\\n\"results\" : [\\n');\n\n    const findPromise = data.name.indexOf('_Join') === 0 ?\n      databaseController.adapter.count(data.name, relationSchema, data.where)\n      : rest.find(req.config, req.auth, data.name,  data.where, { count: true, limit: 0 });\n\n    return findPromise\n      .then((result) => {\n\n        if (Number.isInteger(result)) {\n          result = { count: result };\n        }\n\n        let i = 0;\n        const pageLimit = 1000;\n        let promise = Promise.resolve();\n\n\n        for (i = 0; i < result.count; i += pageLimit) {\n\n          const skip = i;\n          promise = promise.then(() => {\n            return this.exportClassPage(req, data.name, jsonFileStream, data.where, skip, pageLimit);\n          });\n        }\n\n        return promise;\n      })\n      .then(() => {\n\n        jsonFileStream.end(']\\n}');\n\n        return new Promise((resolve) => {\n\n          jsonFileStream.on('close', () => {\n            tmpJsonFile._name = `${data.name.replace(/:/g,'꞉')}.json`;\n\n            resolve(tmpJsonFile);\n          });\n        })\n      });\n  }\n\n  handleExportProgress(req) {\n\n    const databaseController = req.config.database;\n\n    const query = {\n      masterKey: req.info.masterKey,\n      applicationId: req.info.appId\n    };\n\n    return databaseController.find(DefaultExportExportProgressCollectionName, query)\n      .then((response) => {\n        return { response };\n      });\n  }\n\n  handleExport(req) {\n\n    const databaseController = req.config.database;\n\n    const emailControllerAdapter = loadAdapter(req.config.emailAdapter);\n\n    if (!emailControllerAdapter) {\n      return Promise.reject(new Error('You have to setup a Mail Adapter.'));\n    }\n\n    const exportProgress = {\n      id: req.body.name,\n      masterKey: req.info.masterKey,\n      applicationId: req.info.appId\n    };\n\n    databaseController.create(DefaultExportExportProgressCollectionName, exportProgress)\n      .then(() => {\n        return databaseController.loadSchema({ clearCache: true});\n      })\n      .then(schemaController => schemaController.getOneSchema(req.body.name, true))\n      .then((schema) => {\n        const classNames = [ req.body.name ];\n        Object.keys(schema.fields).forEach((fieldName) => {\n          const field = schema.fields[fieldName];\n\n          if (field.type === 'Relation') {\n            classNames.push(`_Join:${fieldName}:${req.body.name}`);\n          }\n        });\n\n        const promisses = classNames.map((name) => {\n          return this.exportClass(req, { name });\n        });\n\n        return Promise.all(promisses)\n      })\n      .then((jsonFiles) => {\n\n        return new Promise((resolve) => {\n          const tmpZipFile = tmp.fileSync();\n          const tmpZipStream = fs.createWriteStream(tmpZipFile.name);\n\n          const zip  = archiver('zip');\n          zip.pipe(tmpZipStream);\n\n          jsonFiles.forEach(tmpJsonFile => {\n            zip.append(fs.readFileSync(tmpJsonFile.name), { name:  tmpJsonFile._name });\n            tmpJsonFile.removeCallback();\n          });\n\n          zip.finalize();\n\n          tmpZipStream.on('close', () => {\n\n            const buf = fs.readFileSync(tmpZipFile.name);\n            tmpZipFile.removeCallback();\n            resolve(buf);\n\n          });\n        });\n\n      })\n      .then((zippedFile) => {\n        const filesController = req.config.filesController;\n        return filesController.createFile(req.config, req.body.name, zippedFile, 'application/zip');\n      })\n      .then((fileData) => {\n\n        return emailControllerAdapter.sendMail({\n          text: `We have successfully exported your data from the class ${req.body.name}.\\n\n        Please download from ${fileData.url}`,\n          link: fileData.url,\n          to: req.body.feedbackEmail,\n          subject: 'Export completed'\n        });\n      })\n      .catch((error) => {\n        return emailControllerAdapter.sendMail({\n          text: `We could not export your data to the class ${req.body.name}. Error: ${error}`,\n          to: req.body.feedbackEmail,\n          subject: 'Export failed'\n        });\n      })\n      .then(() => {\n        return databaseController.destroy(DefaultExportExportProgressCollectionName, exportProgress);\n      });\n\n    return Promise.resolve({response: 'We are exporting your data. You will be notified by e-mail once it is completed.'});\n  }\n\n  mountRoutes() {\n    this.route(\n      'PUT',\n      '/export_data',\n      (req) => { return this.handleExport(req); }\n    );\n\n    this.route(\n      'GET',\n      '/export_progress',\n      (req) => { return this.handleExportProgress(req); }\n    );\n\n  }\n}\n\nexport default ExportRouter;\n"]} \ No newline at end of file diff --git a/lib/Routers/FeaturesRouter.js b/lib/Routers/FeaturesRouter.js index df7fe673b4..4a70a9d362 100644 --- a/lib/Routers/FeaturesRouter.js +++ b/lib/Routers/FeaturesRouter.js @@ -72,4 +72,5 @@ class FeaturesRouter extends _PromiseRouter2.default { }); } } -exports.FeaturesRouter = FeaturesRouter; \ No newline at end of file +exports.FeaturesRouter = FeaturesRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/FilesRouter.js b/lib/Routers/FilesRouter.js index 8ab5e94388..2bb887d417 100644 --- a/lib/Routers/FilesRouter.js +++ b/lib/Routers/FilesRouter.js @@ -202,4 +202,5 @@ function handleFileStream(stream, req, res, contentType) { } }); }); -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/FilesRouter.js"],"names":["Middlewares","FilesRouter","expressRouter","maxUploadSize","router","express","Router","get","getHandler","post","req","res","next","Parse","Error","INVALID_FILE_NAME","allowCrossDomain","BodyParser","raw","type","limit","handleParseHeaders","createHandler","delete","enforceMasterKeyAccess","deleteHandler","config","Config","params","appId","filesController","filename","contentType","mime","getType","isFileStreamable","getFileStream","then","stream","handleFileStream","catch","status","set","end","getFileData","data","length","body","FILE_SAVE_ERROR","match","createFile","result","url","json","e","logger","error","message","deleteFile","FILE_DELETE_ERROR","adapter","getRange","parts","replace","split","start","parseInt","buffer_size","notEnded","notStarted","contentLength","writeHead","seek","gridFileStream","bufferAvail","remainingBytesToWrite","totalBytesWritten","on","buffer","slice","write","close","destroy"],"mappings":"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","file":"FilesRouter.js","sourcesContent":["import express             from 'express';\nimport BodyParser          from 'body-parser';\nimport * as Middlewares    from '../middlewares';\nimport Parse               from 'parse/node';\nimport Config              from '../Config';\nimport mime                from 'mime';\nimport logger              from '../logger';\n\nexport class FilesRouter {\n\n  expressRouter({ maxUploadSize = '20Mb' } = {}) {\n    var router = express.Router();\n    router.get('/files/:appId/:filename', this.getHandler);\n\n    router.post('/files', function(req, res, next) {\n      next(new Parse.Error(Parse.Error.INVALID_FILE_NAME,\n        'Filename not provided.'));\n    });\n\n    router.post('/files/:filename',\n      Middlewares.allowCrossDomain,\n      BodyParser.raw({type: () => { return true; }, limit: maxUploadSize }), // Allow uploads without Content-Type, or with any Content-Type.\n      Middlewares.handleParseHeaders,\n      this.createHandler\n    );\n\n    router.delete('/files/:filename',\n      Middlewares.allowCrossDomain,\n      Middlewares.handleParseHeaders,\n      Middlewares.enforceMasterKeyAccess,\n      this.deleteHandler\n    );\n    return router;\n  }\n\n  getHandler(req, res) {\n    const config = Config.get(req.params.appId);\n    const filesController = config.filesController;\n    const filename = req.params.filename;\n    const contentType = mime.getType(filename);\n    if (isFileStreamable(req, filesController)) {\n      filesController.getFileStream(config, filename).then((stream) => {\n        handleFileStream(stream, req, res, contentType);\n      }).catch(() => {\n        res.status(404);\n        res.set('Content-Type', 'text/plain');\n        res.end('File not found.');\n      });\n    } else {\n      filesController.getFileData(config, filename).then((data) => {\n        res.status(200);\n        res.set('Content-Type', contentType);\n        res.set('Content-Length', data.length);\n        res.end(data);\n      }).catch(() => {\n        res.status(404);\n        res.set('Content-Type', 'text/plain');\n        res.end('File not found.');\n      });\n    }\n  }\n\n  createHandler(req, res, next) {\n    if (!req.body || !req.body.length) {\n      next(new Parse.Error(Parse.Error.FILE_SAVE_ERROR,\n        'Invalid file upload.'));\n      return;\n    }\n\n    if (req.params.filename.length > 128) {\n      next(new Parse.Error(Parse.Error.INVALID_FILE_NAME,\n        'Filename too long.'));\n      return;\n    }\n\n    if (!req.params.filename.match(/^[_a-zA-Z0-9][a-zA-Z0-9@\\.\\ ~_-]*$/)) {\n      next(new Parse.Error(Parse.Error.INVALID_FILE_NAME,\n        'Filename contains invalid characters.'));\n      return;\n    }\n\n    const filename = req.params.filename;\n    const contentType = req.get('Content-type');\n    const config = req.config;\n    const filesController = config.filesController;\n\n    filesController.createFile(config, filename, req.body, contentType).then((result) => {\n      res.status(201);\n      res.set('Location', result.url);\n      res.json(result);\n    }).catch((e) => {\n      logger.error(e.message, e);\n      next(new Parse.Error(Parse.Error.FILE_SAVE_ERROR, 'Could not store file.'));\n    });\n  }\n\n  deleteHandler(req, res, next) {\n    const filesController = req.config.filesController;\n    filesController.deleteFile(req.config, req.params.filename).then(() => {\n      res.status(200);\n      // TODO: return useful JSON here?\n      res.end();\n    }).catch(() => {\n      next(new Parse.Error(Parse.Error.FILE_DELETE_ERROR,\n        'Could not delete file.'));\n    });\n  }\n}\n\nfunction isFileStreamable(req, filesController){\n  return  req.get('Range') && typeof filesController.adapter.getFileStream === 'function';\n}\n\nfunction getRange(req) {\n  const parts = req.get('Range').replace(/bytes=/, \"\").split(\"-\");\n  return { start: parseInt(parts[0], 10), end: parseInt(parts[1], 10) };\n}\n\n// handleFileStream is licenced under Creative Commons Attribution 4.0 International License (https://creativecommons.org/licenses/by/4.0/).\n// Author: LEROIB at weightingformypizza (https://weightingformypizza.wordpress.com/2015/06/24/stream-html5-media-content-like-video-audio-from-mongodb-using-express-and-gridstore/).\nfunction handleFileStream(stream, req, res, contentType) {\n  const buffer_size = 1024 * 1024; //1024Kb\n  // Range request, partiall stream the file\n  let {\n    start, end\n  } = getRange(req);\n\n  const notEnded = (!end && end !== 0);\n  const notStarted = (!start && start !== 0);\n  // No end provided, we want all bytes\n  if (notEnded) {\n    end = stream.length - 1;\n  }\n  // No start provided, we're reading backwards\n  if (notStarted) {\n    start = stream.length - end;\n    end = start + end - 1;\n  }\n\n  // Data exceeds the buffer_size, cap\n  if (end - start >= buffer_size) {\n    end = start + buffer_size - 1;\n  }\n\n  const contentLength = (end - start) + 1;\n\n  res.writeHead(206, {\n    'Content-Range': 'bytes ' + start + '-' + end + '/' + stream.length,\n    'Accept-Ranges': 'bytes',\n    'Content-Length': contentLength,\n    'Content-Type': contentType,\n  });\n\n  stream.seek(start, function () {\n    // get gridFile stream\n    const gridFileStream = stream.stream(true);\n    let bufferAvail = 0;\n    let remainingBytesToWrite = contentLength;\n    let totalBytesWritten = 0;\n    // write to response\n    gridFileStream.on('data', function (data) {\n      bufferAvail += data.length;\n      if (bufferAvail > 0) {\n        // slice returns the same buffer if overflowing\n        // safe to call in any case\n        const buffer = data.slice(0, remainingBytesToWrite);\n        // write the buffer\n        res.write(buffer);\n        // increment total\n        totalBytesWritten += buffer.length;\n        // decrement remaining\n        remainingBytesToWrite -= data.length;\n        // decrement the avaialbe buffer\n        bufferAvail -= buffer.length;\n      }\n      // in case of small slices, all values will be good at that point\n      // we've written enough, end...\n      if (totalBytesWritten >= contentLength) {\n        stream.close();\n        res.end();\n        this.destroy();\n      }\n    });\n  });\n}\n"]} \ No newline at end of file diff --git a/lib/Routers/FunctionsRouter.js b/lib/Routers/FunctionsRouter.js index ef871f47bd..3c07a3cb91 100644 --- a/lib/Routers/FunctionsRouter.js +++ b/lib/Routers/FunctionsRouter.js @@ -106,6 +106,9 @@ class FunctionsRouter extends _PromiseRouter2.default { }, error: function (code, message) { if (!message) { + if (code instanceof Parse.Error) { + return reject(code); + } message = code; code = Parse.Error.SCRIPT_FAILED; } @@ -180,4 +183,5 @@ class FunctionsRouter extends _PromiseRouter2.default { } } } -exports.FunctionsRouter = FunctionsRouter; \ No newline at end of file +exports.FunctionsRouter = FunctionsRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/FunctionsRouter.js"],"names":["Parse","require","triggers","parseObject","obj","Array","isArray","map","item","__type","Object","assign","Date","iso","File","fromJSON","parseParams","params","_","mapValues","FunctionsRouter","PromiseRouter","mountRoutes","route","handleCloudFunction","promiseEnforceMasterKeyAccess","req","handleCloudJob","jobName","body","applicationId","config","jobHandler","jobFunction","getJob","Error","SCRIPT_FAILED","query","request","log","loggerController","headers","ip","status","success","setSucceeded","bind","error","setFailed","message","setMessage","setRunning","then","jobStatus","jobId","objectId","process","nextTick","response","createResponseObject","resolve","reject","result","_encode","code","functionName","theFunction","getFunction","theValidator","getValidator","master","auth","isMaster","user","installationId","info","VALIDATION_ERROR","Promise","userString","id","undefined","cleanInput","logger","truncateLogMessage","JSON","stringify","cleanResult","e","javascriptKey","masterKey"],"mappings":"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","file":"FunctionsRouter.js","sourcesContent":["// FunctionsRouter.js\n\nvar Parse = require('parse/node').Parse,\n  triggers = require('../triggers');\n\nimport PromiseRouter from '../PromiseRouter';\nimport { promiseEnforceMasterKeyAccess } from '../middlewares';\nimport { jobStatusHandler } from '../StatusHandler';\nimport _ from 'lodash';\nimport { logger } from '../logger';\n\nfunction parseObject(obj) {\n  if (Array.isArray(obj)) {\n    return obj.map((item) => {\n      return parseObject(item);\n    });\n  } else if (obj && obj.__type == 'Date') {\n    return Object.assign(new Date(obj.iso), obj);\n  } else if (obj && obj.__type == 'File') {\n    return Parse.File.fromJSON(obj);\n  } else if (obj && typeof obj === 'object') {\n    return parseParams(obj);\n  } else {\n    return obj;\n  }\n}\n\nfunction parseParams(params) {\n  return _.mapValues(params, parseObject);\n}\n\nexport class FunctionsRouter extends PromiseRouter {\n\n  mountRoutes() {\n    this.route('POST', '/functions/:functionName', FunctionsRouter.handleCloudFunction);\n    this.route('POST', '/jobs/:jobName', promiseEnforceMasterKeyAccess, function(req) {\n      return FunctionsRouter.handleCloudJob(req);\n    });\n    this.route('POST', '/jobs', promiseEnforceMasterKeyAccess, function(req) {\n      return FunctionsRouter.handleCloudJob(req);\n    });\n  }\n\n  static handleCloudJob(req) {\n    const jobName = req.params.jobName || req.body.jobName;\n    const applicationId = req.config.applicationId;\n    const jobHandler = jobStatusHandler(req.config);\n    const jobFunction = triggers.getJob(jobName, applicationId);\n    if (!jobFunction) {\n      throw new Parse.Error(Parse.Error.SCRIPT_FAILED, 'Invalid job.');\n    }\n    let params = Object.assign({}, req.body, req.query);\n    params = parseParams(params);\n    const request = {\n      params: params,\n      log: req.config.loggerController,\n      headers: req.config.headers,\n      ip: req.config.ip,\n      jobName\n    };\n    const status = {\n      success: jobHandler.setSucceeded.bind(jobHandler),\n      error: jobHandler.setFailed.bind(jobHandler),\n      message: jobHandler.setMessage.bind(jobHandler)\n    }\n    return jobHandler.setRunning(jobName, params).then((jobStatus) => {\n      request.jobId = jobStatus.objectId\n      // run the function async\n      process.nextTick(() => {\n        jobFunction(request, status);\n      });\n      return {\n        headers: {\n          'X-Parse-Job-Status-Id': jobStatus.objectId\n        },\n        response: {}\n      }\n    });\n  }\n\n  static createResponseObject(resolve, reject, message) {\n    return {\n      success: function(result) {\n        resolve({\n          response: {\n            result: Parse._encode(result)\n          }\n        });\n      },\n      error: function(code, message) {\n        if (!message) {\n          if (code instanceof Parse.Error) {\n            return reject(code)\n          }\n          message = code;\n          code = Parse.Error.SCRIPT_FAILED;\n        }\n        reject(new Parse.Error(code, message));\n      },\n      message: message\n    }\n  }\n\n  static handleCloudFunction(req) {\n    const functionName = req.params.functionName;\n    const applicationId = req.config.applicationId;\n    const theFunction = triggers.getFunction(functionName, applicationId);\n    const theValidator = triggers.getValidator(req.params.functionName, applicationId);\n    if (theFunction) {\n      let params = Object.assign({}, req.body, req.query);\n      params = parseParams(params);\n      var request = {\n        params: params,\n        master: req.auth && req.auth.isMaster,\n        user: req.auth && req.auth.user,\n        installationId: req.info.installationId,\n        log: req.config.loggerController,\n        headers: req.config.headers,\n        ip: req.config.ip,\n        functionName\n      };\n\n      if (theValidator && typeof theValidator === \"function\") {\n        var result = theValidator(request);\n        if (!result) {\n          throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Validation failed.');\n        }\n      }\n\n      return new Promise(function (resolve, reject) {\n        const userString = (req.auth && req.auth.user) ? req.auth.user.id : undefined;\n        const cleanInput = logger.truncateLogMessage(JSON.stringify(params));\n        var response = FunctionsRouter.createResponseObject((result) => {\n          try {\n            const cleanResult = logger.truncateLogMessage(JSON.stringify(result.response.result));\n            logger.info(\n              `Ran cloud function ${functionName} for user ${userString} with:\\n  Input: ${cleanInput }\\n  Result: ${cleanResult }`,\n              {\n                functionName,\n                params,\n                user: userString,\n              }\n            );\n            resolve(result);\n          } catch (e) {\n            reject(e);\n          }\n        }, (error) => {\n          try {\n            logger.error(\n              `Failed running cloud function ${functionName} for user ${userString} with:\\n  Input: ${cleanInput}\\n  Error: ` + JSON.stringify(error),\n              {\n                functionName,\n                error,\n                params,\n                user: userString\n              }\n            );\n            reject(error);\n          } catch (e) {\n            reject(e);\n          }\n        });\n        // Force the keys before the function calls.\n        Parse.applicationId = req.config.applicationId;\n        Parse.javascriptKey = req.config.javascriptKey;\n        Parse.masterKey = req.config.masterKey;\n        theFunction(request, response);\n      });\n    } else {\n      throw new Parse.Error(Parse.Error.SCRIPT_FAILED, `Invalid function: \"${functionName}\"`);\n    }\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/Routers/GlobalConfigRouter.js b/lib/Routers/GlobalConfigRouter.js index 140960dfe8..9cc462c784 100644 --- a/lib/Routers/GlobalConfigRouter.js +++ b/lib/Routers/GlobalConfigRouter.js @@ -58,4 +58,5 @@ class GlobalConfigRouter extends _PromiseRouter2.default { exports.GlobalConfigRouter = GlobalConfigRouter; // global_config.js -exports.default = GlobalConfigRouter; \ No newline at end of file +exports.default = GlobalConfigRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/HooksRouter.js b/lib/Routers/HooksRouter.js index 07a6933ea2..3ec43a8bfb 100644 --- a/lib/Routers/HooksRouter.js +++ b/lib/Routers/HooksRouter.js @@ -114,4 +114,5 @@ class HooksRouter extends _PromiseRouter2.default { } exports.HooksRouter = HooksRouter; -exports.default = HooksRouter; \ No newline at end of file +exports.default = HooksRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/HooksRouter.js"],"names":["middleware","HooksRouter","PromiseRouter","createHook","aHook","config","hooksController","then","hook","response","updateHook","handlePost","req","body","handleGetFunctions","params","functionName","getFunction","foundFunction","Parse","Error","Promise","resolve","getFunctions","functions","err","handleGetTriggers","className","triggerName","getTrigger","foundTrigger","getTriggers","triggers","handleDelete","deleteFunction","deleteTrigger","handleUpdate","url","handlePut","__op","mountRoutes","route","promiseEnforceMasterKeyAccess","bind"],"mappings":"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","file":"HooksRouter.js","sourcesContent":["import { Parse }       from 'parse/node';\nimport PromiseRouter   from '../PromiseRouter';\nimport * as middleware from \"../middlewares\";\n\nexport class HooksRouter extends PromiseRouter {\n  createHook(aHook, config) {\n    return config.hooksController.createHook(aHook).then((hook) => ({response: hook}));\n  }\n\n  updateHook(aHook, config) {\n    return  config.hooksController.updateHook(aHook).then((hook) => ({response: hook}));\n  }\n\n  handlePost(req) {\n    return this.createHook(req.body, req.config);\n  }\n\n  handleGetFunctions(req) {\n    var hooksController = req.config.hooksController;\n    if (req.params.functionName) {\n      return hooksController.getFunction(req.params.functionName).then((foundFunction) => {\n        if (!foundFunction) {\n          throw new Parse.Error(143, `no function named: ${req.params.functionName} is defined`);\n        }\n        return Promise.resolve({response: foundFunction});\n      });\n    }\n\n    return hooksController.getFunctions().then((functions) => {\n      return { response: functions || [] };\n    }, (err) => {\n      throw err;\n    });\n  }\n\n  handleGetTriggers(req) {\n    var hooksController = req.config.hooksController;\n    if (req.params.className && req.params.triggerName) {\n\n      return hooksController.getTrigger(req.params.className, req.params.triggerName).then((foundTrigger) => {\n        if (!foundTrigger) {\n          throw new Parse.Error(143,`class ${req.params.className} does not exist`);\n        }\n        return Promise.resolve({response: foundTrigger});\n      });\n    }\n\n    return hooksController.getTriggers().then((triggers) => ({ response: triggers || [] }));\n  }\n\n  handleDelete(req) {\n    var hooksController = req.config.hooksController;\n    if (req.params.functionName) {\n      return hooksController.deleteFunction(req.params.functionName).then(() => ({response: {}}))\n\n    } else if (req.params.className && req.params.triggerName) {\n      return hooksController.deleteTrigger(req.params.className, req.params.triggerName).then(() => ({response: {}}))\n    }\n    return Promise.resolve({response: {}});\n  }\n\n  handleUpdate(req) {\n    var hook;\n    if (req.params.functionName && req.body.url) {\n      hook = {}\n      hook.functionName = req.params.functionName;\n      hook.url = req.body.url;\n    } else if (req.params.className && req.params.triggerName && req.body.url) {\n      hook = {}\n      hook.className = req.params.className;\n      hook.triggerName = req.params.triggerName;\n      hook.url = req.body.url\n    } else {\n      throw new Parse.Error(143, \"invalid hook declaration\");\n    }\n    return this.updateHook(hook, req.config);\n  }\n\n  handlePut(req) {\n    var body = req.body;\n    if (body.__op == \"Delete\") {\n      return this.handleDelete(req);\n    } else {\n      return this.handleUpdate(req);\n    }\n  }\n\n  mountRoutes() {\n    this.route('GET',  '/hooks/functions', middleware.promiseEnforceMasterKeyAccess, this.handleGetFunctions.bind(this));\n    this.route('GET',  '/hooks/triggers', middleware.promiseEnforceMasterKeyAccess, this.handleGetTriggers.bind(this));\n    this.route('GET',  '/hooks/functions/:functionName', middleware.promiseEnforceMasterKeyAccess, this.handleGetFunctions.bind(this));\n    this.route('GET',  '/hooks/triggers/:className/:triggerName', middleware.promiseEnforceMasterKeyAccess, this.handleGetTriggers.bind(this));\n    this.route('POST', '/hooks/functions', middleware.promiseEnforceMasterKeyAccess, this.handlePost.bind(this));\n    this.route('POST', '/hooks/triggers', middleware.promiseEnforceMasterKeyAccess, this.handlePost.bind(this));\n    this.route('PUT',  '/hooks/functions/:functionName', middleware.promiseEnforceMasterKeyAccess, this.handlePut.bind(this));\n    this.route('PUT',  '/hooks/triggers/:className/:triggerName', middleware.promiseEnforceMasterKeyAccess, this.handlePut.bind(this));\n  }\n}\n\nexport default HooksRouter;\n"]} \ No newline at end of file diff --git a/lib/Routers/IAPValidationRouter.js b/lib/Routers/IAPValidationRouter.js index 0d03e91f41..93948f5c63 100644 --- a/lib/Routers/IAPValidationRouter.js +++ b/lib/Routers/IAPValidationRouter.js @@ -122,4 +122,5 @@ class IAPValidationRouter extends _PromiseRouter2.default { this.route("POST", "/validate_purchase", this.handleRequest); } } -exports.IAPValidationRouter = IAPValidationRouter; \ No newline at end of file +exports.IAPValidationRouter = IAPValidationRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/IAPValidationRouter.js"],"names":["request","require","rest","IAP_SANDBOX_URL","IAP_PRODUCTION_URL","APP_STORE_ERRORS","appStoreError","status","parseInt","errorString","error","validateWithAppStore","url","receipt","Promise","fulfill","reject","post","body","json","err","res","getFileForProductIdentifier","productIdentifier","req","find","config","auth","undefined","info","clientSDK","then","result","products","results","length","Parse","Error","OBJECT_NOT_FOUND","download","resolve","response","IAPValidationRouter","PromiseRouter","handleRequest","INVALID_JSON","base64","process","env","TESTING","bypassAppStoreValidation","successCallback","errorCallback","mountRoutes","route"],"mappings":"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","file":"IAPValidationRouter.js","sourcesContent":["import PromiseRouter from '../PromiseRouter';\nvar request = require(\"request\");\nvar rest = require(\"../rest\");\nimport Parse from 'parse/node';\n\n// TODO move validation logic in IAPValidationController\nconst IAP_SANDBOX_URL = \"https://sandbox.itunes.apple.com/verifyReceipt\";\nconst IAP_PRODUCTION_URL = \"https://buy.itunes.apple.com/verifyReceipt\";\n\nconst APP_STORE_ERRORS = {\n  21000: \"The App Store could not read the JSON object you provided.\",\n  21002: \"The data in the receipt-data property was malformed or missing.\",\n  21003: \"The receipt could not be authenticated.\",\n  21004: \"The shared secret you provided does not match the shared secret on file for your account.\",\n  21005: \"The receipt server is not currently available.\",\n  21006: \"This receipt is valid but the subscription has expired.\",\n  21007: \"This receipt is from the test environment, but it was sent to the production environment for verification. Send it to the test environment instead.\",\n  21008: \"This receipt is from the production environment, but it was sent to the test environment for verification. Send it to the production environment instead.\"\n}\n\nfunction appStoreError(status) {\n  status = parseInt(status);\n  var errorString = APP_STORE_ERRORS[status] || \"unknown error.\";\n  return { status: status, error: errorString }\n}\n\nfunction validateWithAppStore(url, receipt) {\n  return new Promise(function(fulfill, reject) {\n    request.post({\n      url: url,\n      body: { \"receipt-data\": receipt },\n      json: true,\n    }, function(err, res, body) {\n      var status = body.status;\n      if (status == 0) {\n        // No need to pass anything, status is OK\n        return fulfill();\n      }\n      // receipt is from test and should go to test\n      return reject(body);\n    });\n  });\n}\n\nfunction getFileForProductIdentifier(productIdentifier, req) {\n  return rest.find(req.config, req.auth, '_Product', { productIdentifier: productIdentifier }, undefined, req.info.clientSDK).then(function(result){\n    const products = result.results;\n    if (!products || products.length != 1) {\n      // Error not found or too many\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.')\n    }\n\n    var download = products[0].download;\n    return Promise.resolve({response: download});\n  });\n}\n\n\nexport class IAPValidationRouter extends PromiseRouter {\n\n  handleRequest(req) {\n    let receipt = req.body.receipt;\n    const productIdentifier = req.body.productIdentifier;\n\n    if (!receipt || ! productIdentifier) {\n      // TODO: Error, malformed request\n      throw new Parse.Error(Parse.Error.INVALID_JSON, \"missing receipt or productIdentifier\");\n    }\n\n    // Transform the object if there\n    // otherwise assume it's in Base64 already\n    if (typeof receipt == \"object\") {\n      if (receipt[\"__type\"] == \"Bytes\") {\n        receipt = receipt.base64;\n      }\n    }\n\n    if (process.env.TESTING == \"1\" && req.body.bypassAppStoreValidation) {\n      return getFileForProductIdentifier(productIdentifier, req);\n    }\n\n    function successCallback() {\n      return getFileForProductIdentifier(productIdentifier, req);\n    }\n\n    function errorCallback(error) {\n      return Promise.resolve({response: appStoreError(error.status) });\n    }\n\n    return validateWithAppStore(IAP_PRODUCTION_URL, receipt).then(() => {\n\n      return successCallback();\n\n    }, (error) => {\n      if (error.status == 21007) {\n        return validateWithAppStore(IAP_SANDBOX_URL, receipt).then(() => {\n          return successCallback();\n        }, (error) => {\n          return errorCallback(error);\n        }\n        );\n      }\n\n      return errorCallback(error);\n    });\n  }\n\n  mountRoutes() {\n    this.route(\"POST\",\"/validate_purchase\", this.handleRequest);\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/Routers/ImportRouter.js b/lib/Routers/ImportRouter.js index 726bda099b..2c16dbc5e2 100644 --- a/lib/Routers/ImportRouter.js +++ b/lib/Routers/ImportRouter.js @@ -205,4 +205,5 @@ class ImportRouter { } exports.ImportRouter = ImportRouter; -exports.default = ImportRouter; \ No newline at end of file +exports.default = ImportRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/ImportRouter.js"],"names":["middlewares","ImportRouter","getOneSchema","req","className","params","config","database","loadSchema","clearCache","then","schemaController","catch","error","undefined","Promise","reject","Parse","Error","INVALID_CLASS_NAME","INTERNAL_SERVER_ERROR","importRestObject","restObject","targetClass","rest","update","auth","objectId","owningId","relationName","relatedId","info","clientSDK","code","OBJECT_NOT_FOUND","createdAt","updatedAt","create","allowObjectId","getRestObjects","resolve","restObjects","importFile","JSON","parse","file","buffer","toString","e","Array","isArray","results","rows","body","feedbackEmail","emailAdapter","handleImport","emailControllerAdapter","promise","response","fields","hasOwnProperty","type","all","reduce","item","object","index","pageArray","push","bind","length","slice","mainPromise","concat","map","func","sendMail","text","to","subject","wrapPromiseRequest","res","handler","data","json","err","status","send","message","expressRouter","router","express","Router","upload","post","single","allowCrossDomain","handleParseHeaders","enforceMasterKeyAccess"],"mappings":"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","file":"ImportRouter.js","sourcesContent":["import express          from 'express';\nimport { loadAdapter } from '../Adapters/AdapterLoader';\nimport * as middlewares from '../middlewares';\nimport multer           from 'multer';\nimport rest             from '../rest';\nimport { Parse }        from 'parse/node';\n\nexport class ImportRouter {\n\n  getOneSchema(req) {\n\n    const className = req.params.className;\n\n    return req.config.database.loadSchema({clearCache: true})\n      .then(schemaController => schemaController.getOneSchema(className))\n      .catch(error => {\n        if (error === undefined) {\n          return Promise.reject(new Parse.Error(Parse.Error.INVALID_CLASS_NAME,\n            `Class ${className} does not exist.`));\n        } else {\n          return Promise.reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR,\n            'Database adapter error.'));\n        }\n      });\n  }\n\n  importRestObject(req, restObject, targetClass) {\n    if (targetClass) {\n      return rest.update(req.config, req.auth, req.params.className, {objectId: restObject.owningId}, {\n        [req.params.relationName]: {\n          \"__op\": \"AddRelation\",\n          \"objects\": [{\"__type\": \"Pointer\", \"className\": targetClass, \"objectId\": restObject.relatedId}]\n        }\n      }, req.info.clientSDK)\n        .catch(function (error) {\n          if (error.code === Parse.Error.OBJECT_NOT_FOUND) {\n            return Promise.reject(new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found'));\n          } else {\n            return Promise.reject(error);\n          }\n        });\n    }\n\n    if (restObject.createdAt) {\n      delete restObject.createdAt;\n    }\n\n    if (restObject.updatedAt) {\n      delete restObject.updatedAt;\n    }\n\n    if (restObject.objectId) {\n      return rest\n        .update(req.config, req.auth, req.params.className, {objectId: restObject.objectId}, restObject, req.info.clientSDK)\n        .catch(function (error) {\n          if (error.code === Parse.Error.OBJECT_NOT_FOUND) {\n            return rest.create(\n              req.config,\n              req.auth,\n              req.params.className,\n              restObject,\n              req.info.clientSDK,\n              {allowObjectId: true}\n            )\n          } else {\n            return Promise.reject(error);\n          }\n        });\n    }\n\n    return rest.create(req.config, req.auth, req.params.className, restObject);\n  }\n\n  getRestObjects(req) {\n    return new Promise((resolve) => {\n\n      let restObjects = [];\n      let importFile;\n\n      try {\n        importFile = JSON.parse(req.file.buffer.toString());\n      } catch (e) {\n        throw new Error('Failed to parse JSON based on the file sent');\n      }\n\n      if (Array.isArray(importFile)) {\n        restObjects = importFile;\n      } else if (Array.isArray(importFile.results)) {\n        restObjects = importFile.results;\n      } else if (Array.isArray(importFile.rows)) {\n        restObjects = importFile.rows;\n      }\n\n      if (!restObjects) {\n        throw new Error('No data to import');\n      }\n\n      if (req.body.feedbackEmail) {\n        if (!req.config.emailAdapter) {\n          throw new Error('You have to setup a Mail Adapter.');\n        }\n      }\n\n      resolve(restObjects);\n    });\n  }\n\n  handleImport(req) {\n\n    const emailControllerAdapter = loadAdapter(req.config.emailAdapter);\n\n    let promise = null;\n\n    if (req.params.relationName) {\n      promise = this.getOneSchema(req)\n        .then((response) => {\n          if (!response.fields.hasOwnProperty(req.params.relationName)) {\n            throw new Error(`Relation ${req.params.relationName} does not exist in ${req.params.className}.`);\n          } else if (response.fields[req.params.relationName].type !== 'Relation') {\n            throw new Error(`Class ${response.fields[req.params.relationName].targetClass} does not have Relation type.`);\n          }\n\n          const targetClass = response.fields[req.params.relationName].targetClass;\n\n          return Promise.all([this.getRestObjects(req), targetClass]);\n        });\n    }\n    else {\n      promise = Promise.all([this.getRestObjects(req)]);\n    }\n\n    promise = promise\n      .then(([restObjects, targetClass]) => {\n\n        return restObjects.reduce((item, object, index) => {\n\n          item.pageArray.push(this.importRestObject.bind(this, req, object, targetClass));\n\n          if (index && index % 100 === 0 || index === (restObjects.length - 1)) {\n\n            const pageArray = item.pageArray.slice(0);\n            item.pageArray = [];\n\n            item.mainPromise = item.mainPromise\n              .then((results) => {\n                return Promise.all(results.concat(pageArray.map(func => func())));\n              });\n\n          }\n\n          return item;\n        }, { pageArray: [], mainPromise : Promise.resolve([]) }).mainPromise;\n      })\n      .then((results) => {\n        if (req.body.feedbackEmail) {\n          emailControllerAdapter.sendMail({\n            text: `We have successfully imported your data to the class ${req.params.className}${req.params.relationName ? ', relation ' + req.params.relationName : '' }.`,\n            to: req.body.feedbackEmail,\n            subject: 'Import completed'\n          });\n        } else {\n          return Promise.resolve({ response: results });\n        }\n      })\n      .catch((error) => {\n        if (req.body.feedbackEmail) {\n          emailControllerAdapter.sendMail({\n            text: `We could not import your data to the class ${req.params.className}${req.params.relationName ? ', relation ' + req.params.relationName : '' }. Error: ${error}`,\n            to: req.body.feedbackEmail,\n            subject: 'Import failed'\n          });\n        } else {\n          throw new Error('Internal server error: ' + error);\n        }\n\n      });\n\n    if (req.body.feedbackEmail && emailControllerAdapter) {\n      promise = Promise.resolve({ response: 'We are importing your data. You will be notified by e-mail once it is completed.' });\n    }\n\n    return promise;\n  }\n\n  wrapPromiseRequest(req, res, handler) {\n    return handler(req)\n      .then((data) => {\n        res.json(data);\n      })\n      .catch((err) => {\n        res.status(400).send({ message: err.message });\n      })\n  }\n\n  expressRouter() {\n    const router = express.Router();\n    const upload = multer();\n\n    router.post('/import_data/:className',\n      upload.single('importFile'),\n      middlewares.allowCrossDomain,\n      middlewares.handleParseHeaders,\n      middlewares.enforceMasterKeyAccess,\n      (req, res) => this.wrapPromiseRequest(req, res, this.handleImport.bind(this))\n    );\n\n    router.post('/import_relation_data/:className/:relationName',\n      upload.single('importFile'),\n      middlewares.allowCrossDomain,\n      middlewares.handleParseHeaders,\n      middlewares.enforceMasterKeyAccess,\n      (req, res) => this.wrapPromiseRequest(req, res, this.handleImport.bind(this))\n    );\n\n    return router;\n  }\n}\n\nexport default ImportRouter;\n"]} \ No newline at end of file diff --git a/lib/Routers/InstallationsRouter.js b/lib/Routers/InstallationsRouter.js index becd25b183..83626aef3e 100644 --- a/lib/Routers/InstallationsRouter.js +++ b/lib/Routers/InstallationsRouter.js @@ -50,4 +50,5 @@ class InstallationsRouter extends _ClassesRouter2.default { } exports.InstallationsRouter = InstallationsRouter; -exports.default = InstallationsRouter; \ No newline at end of file +exports.default = InstallationsRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/LogsRouter.js b/lib/Routers/LogsRouter.js index 99ed475a83..2f4cfee587 100644 --- a/lib/Routers/LogsRouter.js +++ b/lib/Routers/LogsRouter.js @@ -68,4 +68,5 @@ class LogsRouter extends _PromiseRouter2.default { } exports.LogsRouter = LogsRouter; -exports.default = LogsRouter; \ No newline at end of file +exports.default = LogsRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/PublicAPIRouter.js b/lib/Routers/PublicAPIRouter.js index ef29364807..fd848ff745 100644 --- a/lib/Routers/PublicAPIRouter.js +++ b/lib/Routers/PublicAPIRouter.js @@ -268,4 +268,5 @@ class PublicAPIRouter extends _PromiseRouter2.default { } exports.PublicAPIRouter = PublicAPIRouter; -exports.default = PublicAPIRouter; \ No newline at end of file +exports.default = PublicAPIRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/PublicAPIRouter.js"],"names":["public_html","path","resolve","__dirname","views","PublicAPIRouter","PromiseRouter","verifyEmail","req","token","username","query","appId","params","config","Config","get","invalidRequest","publicServerURL","missingPublicServerURL","invalidLink","userController","then","qs","stringify","Promise","status","location","verifyEmailSuccessURL","invalidVerificationLink","resendVerificationEmail","body","linkSendSuccessURL","linkSendFailURL","changePassword","reject","id","text","fs","readFile","err","data","replace","requestResetPassword","checkResetTokenValidity","applicationId","app","appName","choosePasswordURL","resetPassword","new_password","updatePassword","passwordResetSuccessURL","error","invalidLinkURL","invalidVerificationLinkURL","Error","message","setConfig","mountRoutes","route","expressRouter","router","express","Router","use","static"],"mappings":"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","file":"PublicAPIRouter.js","sourcesContent":["import PromiseRouter from '../PromiseRouter';\nimport Config from '../Config';\nimport express from 'express';\nimport path from 'path';\nimport fs from 'fs';\nimport qs from 'querystring';\n\nconst public_html = path.resolve(__dirname, \"../../public_html\");\nconst views = path.resolve(__dirname, '../../views');\n\nexport class PublicAPIRouter extends PromiseRouter {\n\n  verifyEmail(req) {\n    const { token, username } = req.query;\n    const appId = req.params.appId;\n    const config = Config.get(appId);\n\n    if(!config){\n      this.invalidRequest();\n    }\n\n    if (!config.publicServerURL) {\n      return this.missingPublicServerURL();\n    }\n\n    if (!token || !username) {\n      return this.invalidLink(req);\n    }\n\n    const userController = config.userController;\n    return userController.verifyEmail(username, token).then(() => {\n      const params = qs.stringify({username});\n      return Promise.resolve({\n        status: 302,\n        location: `${config.verifyEmailSuccessURL}?${params}`\n      });\n    }, ()=> {\n      return this.invalidVerificationLink(req);\n    })\n  }\n\n  resendVerificationEmail(req) {\n    const username = req.body.username;\n    const appId = req.params.appId;\n    const config = Config.get(appId);\n\n    if(!config){\n      this.invalidRequest();\n    }\n\n    if (!config.publicServerURL) {\n      return this.missingPublicServerURL();\n    }\n\n    if (!username) {\n      return this.invalidLink(req);\n    }\n\n    const userController = config.userController;\n\n    return userController.resendVerificationEmail(username).then(() => {\n      return Promise.resolve({\n        status: 302,\n        location: `${config.linkSendSuccessURL}`\n      });\n    }, ()=> {\n      return Promise.resolve({\n        status: 302,\n        location: `${config.linkSendFailURL}`\n      });\n    })\n  }\n\n  changePassword(req) {\n    return new Promise((resolve, reject) => {\n      const config = Config.get(req.query.id);\n\n      if(!config){\n        this.invalidRequest();\n      }\n\n      if (!config.publicServerURL) {\n        return resolve({\n          status: 404,\n          text: 'Not found.'\n        });\n      }\n      // Should we keep the file in memory or leave like that?\n      fs.readFile(path.resolve(views, \"choose_password\"), 'utf-8', (err, data) => {\n        if (err) {\n          return reject(err);\n        }\n        data = data.replace(\"PARSE_SERVER_URL\", `'${config.publicServerURL}'`);\n        resolve({\n          text: data\n        })\n      });\n    });\n  }\n\n  requestResetPassword(req) {\n\n    const config = req.config;\n\n    if(!config){\n      this.invalidRequest();\n    }\n\n    if (!config.publicServerURL) {\n      return this.missingPublicServerURL();\n    }\n\n    const { username, token } = req.query;\n\n    if (!username || !token) {\n      return this.invalidLink(req);\n    }\n\n    return config.userController.checkResetTokenValidity(username, token).then(() => {\n      const params = qs.stringify({token, id: config.applicationId, username, app: config.appName, });\n      return Promise.resolve({\n        status: 302,\n        location: `${config.choosePasswordURL}?${params}`\n      })\n    }, () => {\n      return this.invalidLink(req);\n    })\n  }\n\n  resetPassword(req) {\n\n    const config = req.config;\n\n    if(!config){\n      this.invalidRequest();\n    }\n\n    if (!config.publicServerURL) {\n      return this.missingPublicServerURL();\n    }\n\n    const {\n      username,\n      token,\n      new_password\n    } = req.body;\n\n    if (!username || !token || !new_password) {\n      return this.invalidLink(req);\n    }\n\n    return config.userController.updatePassword(username, token, new_password).then(() => {\n      const params = qs.stringify({username: username});\n      return Promise.resolve({\n        status: 302,\n        location: `${config.passwordResetSuccessURL}?${params}`\n      });\n    }, (err) => {\n      const params = qs.stringify({username: username, token: token, id: config.applicationId, error:err, app:config.appName});\n      return Promise.resolve({\n        status: 302,\n        location: `${config.choosePasswordURL}?${params}`\n      });\n    });\n\n  }\n\n  invalidLink(req) {\n    return Promise.resolve({\n      status: 302,\n      location: req.config.invalidLinkURL\n    });\n  }\n\n  invalidVerificationLink(req) {\n    const config = req.config;\n    if (req.query.username && req.params.appId) {\n      const params = qs.stringify({username: req.query.username, appId: req.params.appId});\n      return Promise.resolve({\n        status: 302,\n        location: `${config.invalidVerificationLinkURL}?${params}`\n      });\n    } else {\n      return this.invalidLink(req);\n    }\n  }\n\n  missingPublicServerURL() {\n    return Promise.resolve({\n      text:  'Not found.',\n      status: 404\n    });\n  }\n\n  invalidRequest() {\n    const error = new Error();\n    error.status = 403;\n    error.message = \"unauthorized\";\n    throw error;\n  }\n\n  setConfig(req) {\n    req.config = Config.get(req.params.appId);\n    return Promise.resolve();\n  }\n\n  mountRoutes() {\n    this.route('GET','/apps/:appId/verify_email',\n      req => { this.setConfig(req) },\n      req => { return this.verifyEmail(req); });\n\n    this.route('POST', '/apps/:appId/resend_verification_email',\n      req => { this.setConfig(req); },\n      req => { return this.resendVerificationEmail(req); });\n\n    this.route('GET','/apps/choose_password',\n      req => { return this.changePassword(req); });\n\n    this.route('POST','/apps/:appId/request_password_reset',\n      req => { this.setConfig(req) },\n      req => { return this.resetPassword(req); });\n\n    this.route('GET','/apps/:appId/request_password_reset',\n      req => { this.setConfig(req) },\n      req => { return this.requestResetPassword(req); });\n  }\n\n  expressRouter() {\n    const router = express.Router();\n    router.use(\"/apps\", express.static(public_html));\n    router.use(\"/\", super.expressRouter());\n    return router;\n  }\n}\n\nexport default PublicAPIRouter;\n"]} \ No newline at end of file diff --git a/lib/Routers/PurgeRouter.js b/lib/Routers/PurgeRouter.js index 0577ab5951..0d626b9c67 100644 --- a/lib/Routers/PurgeRouter.js +++ b/lib/Routers/PurgeRouter.js @@ -13,6 +13,10 @@ var _middlewares = require('../middlewares'); var middleware = _interopRequireWildcard(_middlewares); +var _node = require('parse/node'); + +var _node2 = _interopRequireDefault(_node); + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -21,7 +25,7 @@ class PurgeRouter extends _PromiseRouter2.default { handlePurge(req) { if (req.auth.isReadOnly) { - throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to purge a schema.'); + throw new _node2.default.Error(_node2.default.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\'t allowed to purge a schema.'); } return req.config.database.purgeCollection(req.params.className).then(() => { var cacheAdapter = req.config.cacheController; @@ -31,6 +35,11 @@ class PurgeRouter extends _PromiseRouter2.default { cacheAdapter.role.clear(); } return { response: {} }; + }).catch(error => { + if (!error || error && error.code === _node2.default.Error.OBJECT_NOT_FOUND) { + return { response: {} }; + } + throw error; }); } @@ -42,4 +51,5 @@ class PurgeRouter extends _PromiseRouter2.default { } exports.PurgeRouter = PurgeRouter; -exports.default = PurgeRouter; \ No newline at end of file +exports.default = PurgeRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/PushRouter.js b/lib/Routers/PushRouter.js index a0cb95c9cf..d6307add24 100644 --- a/lib/Routers/PushRouter.js +++ b/lib/Routers/PushRouter.js @@ -85,4 +85,5 @@ class PushRouter extends _PromiseRouter2.default { } exports.PushRouter = PushRouter; -exports.default = PushRouter; \ No newline at end of file +exports.default = PushRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/RolesRouter.js b/lib/Routers/RolesRouter.js index 05ae6cccf6..d4b6c8d864 100644 --- a/lib/Routers/RolesRouter.js +++ b/lib/Routers/RolesRouter.js @@ -36,4 +36,5 @@ class RolesRouter extends _ClassesRouter2.default { } exports.RolesRouter = RolesRouter; -exports.default = RolesRouter; \ No newline at end of file +exports.default = RolesRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/SchemasRouter.js b/lib/Routers/SchemasRouter.js index 01f909fcd6..3100be7b19 100644 --- a/lib/Routers/SchemasRouter.js +++ b/lib/Routers/SchemasRouter.js @@ -93,4 +93,5 @@ class SchemasRouter extends _PromiseRouter2.default { this.route('DELETE', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, deleteSchema); } } -exports.SchemasRouter = SchemasRouter; \ No newline at end of file +exports.SchemasRouter = SchemasRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/SchemasRouter.js"],"names":["middleware","Parse","require","SchemaController","classNameMismatchResponse","bodyClass","pathClass","Error","INVALID_CLASS_NAME","getAllSchemas","req","config","database","loadSchema","clearCache","then","schemaController","getAllClasses","schemas","response","results","getOneSchema","className","params","schema","catch","error","undefined","INTERNAL_SERVER_ERROR","createSchema","auth","isReadOnly","OPERATION_FORBIDDEN","body","path","addClassIfNotExists","fields","classLevelPermissions","indexes","modifySchema","submittedFields","updateClass","result","deleteSchema","classNameIsValid","invalidClassNameMessage","SchemasRouter","PromiseRouter","mountRoutes","route","promiseEnforceMasterKeyAccess"],"mappings":"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","file":"SchemasRouter.js","sourcesContent":["// schemas.js\n\nvar Parse = require('parse/node').Parse,\n  SchemaController = require('../Controllers/SchemaController');\n\nimport PromiseRouter   from '../PromiseRouter';\nimport * as middleware from \"../middlewares\";\n\nfunction classNameMismatchResponse(bodyClass, pathClass) {\n  throw new Parse.Error(\n    Parse.Error.INVALID_CLASS_NAME,\n    `Class name mismatch between ${bodyClass} and ${pathClass}.`\n  );\n}\n\nfunction getAllSchemas(req) {\n  return req.config.database.loadSchema({ clearCache: true})\n    .then(schemaController => schemaController.getAllClasses(true))\n    .then(schemas => ({ response: { results: schemas } }));\n}\n\nfunction getOneSchema(req) {\n  const className = req.params.className;\n  return req.config.database.loadSchema({ clearCache: true})\n    .then(schemaController => schemaController.getOneSchema(className, true))\n    .then(schema => ({ response: schema }))\n    .catch(error => {\n      if (error === undefined) {\n        throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${className} does not exist.`);\n      } else {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.');\n      }\n    });\n}\n\nfunction createSchema(req) {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\\'t allowed to create a schema.');\n  }\n  if (req.params.className && req.body.className) {\n    if (req.params.className != req.body.className) {\n      return classNameMismatchResponse(req.body.className, req.params.className);\n    }\n  }\n\n  const className = req.params.className || req.body.className;\n  if (!className) {\n    throw new Parse.Error(135, `POST ${req.path} needs a class name.`);\n  }\n\n  return req.config.database.loadSchema({ clearCache: true})\n    .then(schema => schema.addClassIfNotExists(className, req.body.fields, req.body.classLevelPermissions, req.body.indexes))\n    .then(schema => ({ response: schema }));\n}\n\nfunction modifySchema(req) {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\\'t allowed to update a schema.');\n  }\n  if (req.body.className && req.body.className != req.params.className) {\n    return classNameMismatchResponse(req.body.className, req.params.className);\n  }\n\n  const submittedFields = req.body.fields || {};\n  const className = req.params.className;\n\n  return req.config.database.loadSchema({ clearCache: true})\n    .then(schema => schema.updateClass(className, submittedFields, req.body.classLevelPermissions, req.body.indexes, req.config.database))\n    .then(result => ({response: result}));\n}\n\nconst deleteSchema = req => {\n  if (req.auth.isReadOnly) {\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, 'read-only masterKey isn\\'t allowed to delete a schema.');\n  }\n  if (!SchemaController.classNameIsValid(req.params.className)) {\n    throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, SchemaController.invalidClassNameMessage(req.params.className));\n  }\n  return req.config.database.deleteSchema(req.params.className)\n    .then(() => ({ response: {} }));\n}\n\nexport class SchemasRouter extends PromiseRouter {\n  mountRoutes() {\n    this.route('GET', '/schemas', middleware.promiseEnforceMasterKeyAccess, getAllSchemas);\n    this.route('GET', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, getOneSchema);\n    this.route('POST', '/schemas', middleware.promiseEnforceMasterKeyAccess, createSchema);\n    this.route('POST', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, createSchema);\n    this.route('PUT', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, modifySchema);\n    this.route('DELETE', '/schemas/:className', middleware.promiseEnforceMasterKeyAccess, deleteSchema);\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/Routers/SessionsRouter.js b/lib/Routers/SessionsRouter.js index 5a29c218aa..578db0d165 100644 --- a/lib/Routers/SessionsRouter.js +++ b/lib/Routers/SessionsRouter.js @@ -101,4 +101,5 @@ class SessionsRouter extends _ClassesRouter2.default { } exports.SessionsRouter = SessionsRouter; -exports.default = SessionsRouter; \ No newline at end of file +exports.default = SessionsRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/Routers/UsersRouter.js b/lib/Routers/UsersRouter.js index 8d3fec1132..529d645065 100644 --- a/lib/Routers/UsersRouter.js +++ b/lib/Routers/UsersRouter.js @@ -56,14 +56,109 @@ class UsersRouter extends _ClassesRouter2.default { } } + /** + * Validates a password request in login and verifyPassword + * @param {Object} req The request + * @returns {Object} User object + * @private + */ + _authenticateUserFromRequest(req) { + return new Promise((resolve, reject) => { + // Use query parameters instead if provided in url + let payload = req.body; + if (!payload.username && req.query.username || !payload.email && req.query.email) { + payload = req.query; + } + const { + username, + email, + password + } = payload; + + // TODO: use the right error codes / descriptions. + if (!username && !email) { + throw new _node2.default.Error(_node2.default.Error.USERNAME_MISSING, 'username/email is required.'); + } + if (!password) { + throw new _node2.default.Error(_node2.default.Error.PASSWORD_MISSING, 'password is required.'); + } + if (typeof password !== 'string' || email && typeof email !== 'string' || username && typeof username !== 'string') { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + + let user; + let isValidPassword = false; + let query; + if (email && username) { + query = { email, username }; + } else if (email) { + query = { email }; + } else { + query = { $or: [{ username }, { email: username }] }; + } + return req.config.database.find('_User', query).then(results => { + if (!results.length) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + + if (results.length > 1) { + // corner case where user1 has username == user2 email + req.config.loggerController.warn('There is a user which email is the same as another user\'s username, logging in based on username'); + user = results.filter(user => user.username === username)[0]; + } else { + user = results[0]; + } + + return _password2.default.compare(password, user.password); + }).then(correct => { + isValidPassword = correct; + const accountLockoutPolicy = new _AccountLockout2.default(user, req.config); + return accountLockoutPolicy.handleLoginAttempt(isValidPassword); + }).then(() => { + if (!isValidPassword) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + // Ensure the user isn't locked out + // A locked out user won't be able to login + // To lock a user out, just set the ACL to `masterKey` only ({}). + // Empty ACL is OK + if (!req.auth.isMaster && user.ACL && Object.keys(user.ACL).length == 0) { + throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) { + throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, 'User email is not verified.'); + } + + delete user.password; + + // Sometimes the authData still has null on that keys + // https://github.com/parse-community/parse-server/issues/935 + if (user.authData) { + Object.keys(user.authData).forEach(provider => { + if (user.authData[provider] === null) { + delete user.authData[provider]; + } + }); + if (Object.keys(user.authData).length == 0) { + delete user.authData; + } + } + + return resolve(user); + }).catch(error => { + return reject(error); + }); + }); + } + handleMe(req) { if (!req.info || !req.info.sessionToken) { - throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } const sessionToken = req.info.sessionToken; return _rest2.default.find(req.config, _Auth2.default.master(req.config), '_Session', { sessionToken }, { include: 'user' }, req.info.clientSDK).then(response => { if (!response.results || response.results.length == 0 || !response.results[0].user) { - throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new _node2.default.Error(_node2.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } else { const user = response.results[0].user; // Send token back on the login, because SDKs expect that. @@ -78,63 +173,10 @@ class UsersRouter extends _ClassesRouter2.default { } handleLogIn(req) { - // Use query parameters instead if provided in url - let payload = req.body; - if (!payload.username && req.query.username || !payload.email && req.query.email) { - payload = req.query; - } - const { - username, - email, - password - } = payload; - - // TODO: use the right error codes / descriptions. - if (!username && !email) { - throw new _node2.default.Error(_node2.default.Error.USERNAME_MISSING, 'username/email is required.'); - } - if (!password) { - throw new _node2.default.Error(_node2.default.Error.PASSWORD_MISSING, 'password is required.'); - } - if (typeof password !== 'string' || email && typeof email !== 'string' || username && typeof username !== 'string') { - throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); - } - let user; - let isValidPassword = false; - let query; - if (email && username) { - query = { email, username }; - } else if (email) { - query = { email }; - } else { - query = { $or: [{ username }, { email: username }] }; - } - return req.config.database.find('_User', query).then(results => { - if (!results.length) { - throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); - } + return this._authenticateUserFromRequest(req).then(res => { - if (results.length > 1) { - // corner case where user1 has username == user2 email - req.config.loggerController.warn('There is a user which email is the same as another user\'s username, logging in based on username'); - user = results.filter(user => user.username === username)[0]; - } else { - user = results[0]; - } - - if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) { - throw new _node2.default.Error(_node2.default.Error.EMAIL_NOT_FOUND, 'User email is not verified.'); - } - return _password2.default.compare(password, user.password); - }).then(correct => { - isValidPassword = correct; - const accountLockoutPolicy = new _AccountLockout2.default(user, req.config); - return accountLockoutPolicy.handleLoginAttempt(isValidPassword); - }).then(() => { - if (!isValidPassword) { - throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); - } + user = res; // handle password expiry policy if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) { @@ -157,30 +199,18 @@ class UsersRouter extends _ClassesRouter2.default { } } - delete user.password; - // Remove hidden properties. UsersRouter.removeHiddenProperties(user); - // Sometimes the authData still has null on that keys - // https://github.com/parse-community/parse-server/issues/935 - if (user.authData) { - Object.keys(user.authData).forEach(provider => { - if (user.authData[provider] === null) { - delete user.authData[provider]; - } - }); - if (Object.keys(user.authData).length == 0) { - delete user.authData; - } - } const { sessionData, createSession - } = _Auth2.default.createSession(req.config, { userId: user.objectId, createdWith: { + } = _Auth2.default.createSession(req.config, { + userId: user.objectId, createdWith: { 'action': 'login', 'authProvider': 'password' - }, installationId: req.info.installationId }); + }, installationId: req.info.installationId + }); user.sessionToken = sessionData.sessionToken; @@ -192,6 +222,18 @@ class UsersRouter extends _ClassesRouter2.default { }); } + handleVerifyPassword(req) { + return this._authenticateUserFromRequest(req).then(user => { + + // Remove hidden properties. + UsersRouter.removeHiddenProperties(user); + + return { response: user }; + }).catch(error => { + throw error; + }); + } + handleLogOut(req) { const success = { response: {} }; if (req.info && req.info.sessionToken) { @@ -315,9 +357,13 @@ class UsersRouter extends _ClassesRouter2.default { this.route('POST', '/verificationEmailRequest', req => { return this.handleVerificationEmailRequest(req); }); + this.route('GET', '/verifyPassword', req => { + return this.handleVerifyPassword(req); + }); } } exports.UsersRouter = UsersRouter; // These methods handle the User-related routes. -exports.default = UsersRouter; \ No newline at end of file +exports.default = UsersRouter; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/UsersRouter.js"],"names":["UsersRouter","ClassesRouter","className","removeHiddenProperties","obj","key","hasOwnProperty","test","_authenticateUserFromRequest","req","Promise","resolve","reject","payload","body","username","query","email","password","Parse","Error","USERNAME_MISSING","PASSWORD_MISSING","OBJECT_NOT_FOUND","user","isValidPassword","$or","config","database","find","then","results","length","loggerController","warn","filter","passwordCrypto","compare","correct","accountLockoutPolicy","AccountLockout","handleLoginAttempt","auth","isMaster","ACL","Object","keys","verifyUserEmails","preventLoginWithUnverifiedEmail","emailVerified","EMAIL_NOT_FOUND","authData","forEach","provider","catch","error","handleMe","info","sessionToken","INVALID_SESSION_TOKEN","rest","Auth","master","include","clientSDK","response","handleLogIn","res","passwordPolicy","maxPasswordAge","changedAt","_password_changed_at","Date","update","_encode","__type","iso","expiresAt","getTime","sessionData","createSession","userId","objectId","createdWith","installationId","filesController","expandFilesInObject","handleVerifyPassword","handleLogOut","success","undefined","records","del","_throwOnBadEmailConfig","Config","validateEmailConfiguration","emailAdapter","userController","adapter","appName","publicServerURL","emailVerifyTokenValidityDuration","e","INTERNAL_SERVER_ERROR","handleResetRequest","EMAIL_MISSING","INVALID_EMAIL_ADDRESS","sendPasswordResetEmail","err","code","handleVerificationEmailRequest","OTHER_CAUSE","regenerateEmailVerifyToken","sendVerificationEmail","mountRoutes","route","handleFind","handleCreate","handleGet","handleUpdate","handleDelete"],"mappings":"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","file":"UsersRouter.js","sourcesContent":["// These methods handle the User-related routes.\n\nimport Parse from 'parse/node';\nimport Config from '../Config';\nimport AccountLockout from '../AccountLockout';\nimport ClassesRouter from './ClassesRouter';\nimport rest from '../rest';\nimport Auth from '../Auth';\nimport passwordCrypto from '../password';\n\nexport class UsersRouter extends ClassesRouter {\n\n  className() {\n    return '_User';\n  }\n\n  /**\n   * Removes all \"_\" prefixed properties from an object, except \"__type\"\n   * @param {Object} obj An object.\n   */\n  static removeHiddenProperties(obj) {\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        // Regexp comes from Parse.Object.prototype.validate\n        if (key !== \"__type\" && !(/^[A-Za-z][0-9A-Za-z_]*$/).test(key)) {\n          delete obj[key];\n        }\n      }\n    }\n  }\n\n  /**\n   * Validates a password request in login and verifyPassword\n   * @param {Object} req The request\n   * @returns {Object} User object\n   * @private\n   */\n  _authenticateUserFromRequest(req) {\n    return new Promise((resolve, reject) => {\n      // Use query parameters instead if provided in url\n      let payload = req.body;\n      if (!payload.username && req.query.username || !payload.email && req.query.email) {\n        payload = req.query;\n      }\n      const {\n        username,\n        email,\n        password,\n      } = payload;\n\n      // TODO: use the right error codes / descriptions.\n      if (!username && !email) {\n        throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'username/email is required.');\n      }\n      if (!password) {\n        throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required.');\n      }\n      if (typeof password !== 'string'\n        || email && typeof email !== 'string'\n        || username && typeof username !== 'string') {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n      }\n\n      let user;\n      let isValidPassword = false;\n      let query;\n      if (email && username) {\n        query = { email, username };\n      } else if (email) {\n        query = { email };\n      } else {\n        query = { $or: [{ username }, { email: username }] };\n      }\n      return req.config.database.find('_User', query)\n        .then((results) => {\n          if (!results.length) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n\n          if (results.length > 1) { // corner case where user1 has username == user2 email\n            req.config.loggerController.warn('There is a user which email is the same as another user\\'s username, logging in based on username');\n            user = results.filter((user) => user.username === username)[0];\n          } else {\n            user = results[0];\n          }\n\n          return passwordCrypto.compare(password, user.password);\n        })\n        .then((correct) => {\n          isValidPassword = correct;\n          const accountLockoutPolicy = new AccountLockout(user, req.config);\n          return accountLockoutPolicy.handleLoginAttempt(isValidPassword);\n        })\n        .then(() => {\n          if (!isValidPassword) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n          // Ensure the user isn't locked out\n          // A locked out user won't be able to login\n          // To lock a user out, just set the ACL to `masterKey` only  ({}).\n          // Empty ACL is OK\n          if (!req.auth.isMaster && user.ACL && Object.keys(user.ACL).length == 0) {\n            throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.');\n          }\n          if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) {\n            throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.');\n          }\n\n          delete user.password;\n\n          // Sometimes the authData still has null on that keys\n          // https://github.com/parse-community/parse-server/issues/935\n          if (user.authData) {\n            Object.keys(user.authData).forEach((provider) => {\n              if (user.authData[provider] === null) {\n                delete user.authData[provider];\n              }\n            });\n            if (Object.keys(user.authData).length == 0) {\n              delete user.authData;\n            }\n          }\n\n          return resolve(user);\n        }).catch((error) => {\n          return reject(error);\n        });\n    });\n  }\n\n  handleMe(req) {\n    if (!req.info || !req.info.sessionToken) {\n      throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n    }\n    const sessionToken = req.info.sessionToken;\n    return rest.find(req.config, Auth.master(req.config), '_Session',\n      { sessionToken },\n      { include: 'user' }, req.info.clientSDK)\n      .then((response) => {\n        if (!response.results ||\n          response.results.length == 0 ||\n          !response.results[0].user) {\n          throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n        } else {\n          const user = response.results[0].user;\n          // Send token back on the login, because SDKs expect that.\n          user.sessionToken = sessionToken;\n\n          // Remove hidden properties.\n          UsersRouter.removeHiddenProperties(user);\n\n          return { response: user };\n        }\n      });\n  }\n\n  handleLogIn(req) {\n    let user;\n    return this._authenticateUserFromRequest(req)\n      .then((res) => {\n\n        user = res;\n\n        // handle password expiry policy\n        if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) {\n          let changedAt = user._password_changed_at;\n\n          if (!changedAt) {\n            // password was created before expiry policy was enabled.\n            // simply update _User object so that it will start enforcing from now\n            changedAt = new Date();\n            req.config.database.update('_User', { username: user.username },\n              { _password_changed_at: Parse._encode(changedAt) });\n          } else {\n            // check whether the password has expired\n            if (changedAt.__type == 'Date') {\n              changedAt = new Date(changedAt.iso);\n            }\n            // Calculate the expiry time.\n            const expiresAt = new Date(changedAt.getTime() + 86400000 * req.config.passwordPolicy.maxPasswordAge);\n            if (expiresAt < new Date()) // fail of current time is past password expiry time\n              throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Your password has expired. Please reset your password.');\n          }\n        }\n\n        // Remove hidden properties.\n        UsersRouter.removeHiddenProperties(user);\n\n        const {\n          sessionData,\n          createSession\n        } = Auth.createSession(req.config, {\n          userId: user.objectId, createdWith: {\n            'action': 'login',\n            'authProvider': 'password'\n          }, installationId: req.info.installationId\n        });\n\n        user.sessionToken = sessionData.sessionToken;\n\n        req.config.filesController.expandFilesInObject(req.config, user);\n\n        return createSession();\n      })\n      .then(() => {\n        return { response: user };\n      });\n  }\n\n  handleVerifyPassword(req) {\n    return this._authenticateUserFromRequest(req)\n      .then((user) => {\n\n        // Remove hidden properties.\n        UsersRouter.removeHiddenProperties(user);\n\n        return { response: user };\n      }).catch((error) => {\n        throw error;\n      });\n  }\n\n  handleLogOut(req) {\n    const success = { response: {} };\n    if (req.info && req.info.sessionToken) {\n      return rest.find(req.config, Auth.master(req.config), '_Session',\n        { sessionToken: req.info.sessionToken }, undefined, req.info.clientSDK\n      ).then((records) => {\n        if (records.results && records.results.length) {\n          return rest.del(req.config, Auth.master(req.config), '_Session',\n            records.results[0].objectId\n          ).then(() => {\n            return Promise.resolve(success);\n          });\n        }\n        return Promise.resolve(success);\n      });\n    }\n    return Promise.resolve(success);\n  }\n\n  _throwOnBadEmailConfig(req) {\n    try {\n      Config.validateEmailConfiguration({\n        emailAdapter: req.config.userController.adapter,\n        appName: req.config.appName,\n        publicServerURL: req.config.publicServerURL,\n        emailVerifyTokenValidityDuration: req.config.emailVerifyTokenValidityDuration\n      });\n    } catch (e) {\n      if (typeof e === 'string') {\n        // Maybe we need a Bad Configuration error, but the SDKs won't understand it. For now, Internal Server Error.\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'An appName, publicServerURL, and emailAdapter are required for password reset and email verification functionality.');\n      } else {\n        throw e;\n      }\n    }\n  }\n\n  handleResetRequest(req) {\n    this._throwOnBadEmailConfig(req);\n\n    const { email } = req.body;\n    if (!email) {\n      throw new Parse.Error(Parse.Error.EMAIL_MISSING, \"you must provide an email\");\n    }\n    if (typeof email !== 'string') {\n      throw new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');\n    }\n    const userController = req.config.userController;\n    return userController.sendPasswordResetEmail(email).then(() => {\n      return Promise.resolve({\n        response: {}\n      });\n    }, err => {\n      if (err.code === Parse.Error.OBJECT_NOT_FOUND) {\n        throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, `No user found with email ${email}.`);\n      } else {\n        throw err;\n      }\n    });\n  }\n\n  handleVerificationEmailRequest(req) {\n    this._throwOnBadEmailConfig(req);\n\n    const { email } = req.body;\n    if (!email) {\n      throw new Parse.Error(Parse.Error.EMAIL_MISSING, 'you must provide an email');\n    }\n    if (typeof email !== 'string') {\n      throw new Parse.Error(Parse.Error.INVALID_EMAIL_ADDRESS, 'you must provide a valid email string');\n    }\n\n    return req.config.database.find('_User', { email: email }).then((results) => {\n      if (!results.length || results.length < 1) {\n        throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, `No user found with email ${email}`);\n      }\n      const user = results[0];\n\n      // remove password field, messes with saving on postgres\n      delete user.password;\n\n      if (user.emailVerified) {\n        throw new Parse.Error(Parse.Error.OTHER_CAUSE, `Email ${email} is already verified.`);\n      }\n\n      const userController = req.config.userController;\n      return userController.regenerateEmailVerifyToken(user).then(() => {\n        userController.sendVerificationEmail(user);\n        return { response: {} };\n      });\n    });\n  }\n\n\n  mountRoutes() {\n    this.route('GET', '/users', req => { return this.handleFind(req); });\n    this.route('POST', '/users', req => { return this.handleCreate(req); });\n    this.route('GET', '/users/me', req => { return this.handleMe(req); });\n    this.route('GET', '/users/:objectId', req => { return this.handleGet(req); });\n    this.route('PUT', '/users/:objectId', req => { return this.handleUpdate(req); });\n    this.route('DELETE', '/users/:objectId', req => { return this.handleDelete(req); });\n    this.route('GET', '/login', req => { return this.handleLogIn(req); });\n    this.route('POST', '/login', req => { return this.handleLogIn(req); });\n    this.route('POST', '/logout', req => { return this.handleLogOut(req); });\n    this.route('POST', '/requestPasswordReset', req => { return this.handleResetRequest(req); });\n    this.route('POST', '/verificationEmailRequest', req => { return this.handleVerificationEmailRequest(req); });\n    this.route('GET', '/verifyPassword', req => { return this.handleVerifyPassword(req); });\n  }\n}\n\nexport default UsersRouter;\n"]} \ No newline at end of file diff --git a/lib/StatusHandler.js b/lib/StatusHandler.js index 1abf9778a2..f5d6ef4f55 100644 --- a/lib/StatusHandler.js +++ b/lib/StatusHandler.js @@ -321,4 +321,5 @@ function pushStatusHandler(config, existingObjectId) { }); return Object.freeze(rval); -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/StatusHandler.js"],"names":["flatten","jobStatusHandler","pushStatusHandler","PUSH_STATUS_COLLECTION","JOB_STATUS_COLLECTION","incrementOp","object","key","amount","__op","array","flattened","i","length","Array","isArray","concat","push","statusHandler","className","database","lastPromise","Promise","resolve","create","then","update","where","Object","freeze","restStatusHandler","config","auth","Auth","master","rest","response","assign","objectId","jobStatus","objectIdSize","handler","setRunning","jobName","params","now","Date","status","source","createdAt","ACL","setMessage","message","setSucceeded","setFinalStatus","setFailed","undefined","finishedAt","existingObjectId","pushStatus","setInitial","body","options","pushTime","toISOString","hasOwnProperty","hasPushScheduledSupport","push_time","logger","warn","data","payloadString","JSON","stringify","pushHash","alert","query","payload","title","expiry","expiration_time","expiration_interval","numSent","result","batches","verbose","count","trackSent","results","UTCOffset","cleanupInstallations","process","env","PARSE_SERVER_CLEANUP_INVALID_INSTALLATIONS","numFailed","devicesToRemove","reduce","memo","device","deviceType","transmitted","offsetKey","error","deviceToken","token","forEach","info","acl","many","res","complete","fail","err","errorMessage","rval","defineProperty","get"],"mappings":"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","file":"StatusHandler.js","sourcesContent":["import { md5Hash, newObjectId } from './cryptoUtils';\nimport { logger }               from './logger';\nimport rest                     from './rest';\nimport Auth                     from './Auth';\n\nconst PUSH_STATUS_COLLECTION = '_PushStatus';\nconst JOB_STATUS_COLLECTION = '_JobStatus';\n\nconst incrementOp = function(object = {}, key, amount = 1) {\n  if (!object[key]) {\n    object[key] = {__op: 'Increment', amount: amount}\n  } else {\n    object[key].amount += amount;\n  }\n  return object[key];\n}\n\nexport function flatten(array) {\n  var flattened = [];\n  for(var i = 0; i < array.length; i++) {\n    if(Array.isArray(array[i])) {\n      flattened = flattened.concat(flatten(array[i]));\n    } else {\n      flattened.push(array[i]);\n    }\n  }\n  return flattened;\n}\n\nfunction statusHandler(className, database) {\n  let lastPromise = Promise.resolve();\n\n  function create(object) {\n    lastPromise = lastPromise.then(() => {\n      return database.create(className, object).then(() => {\n        return Promise.resolve(object);\n      });\n    });\n    return lastPromise;\n  }\n\n  function update(where, object) {\n    lastPromise = lastPromise.then(() => {\n      return database.update(className, where, object);\n    });\n    return lastPromise;\n  }\n\n  return Object.freeze({\n    create,\n    update\n  })\n}\n\nfunction restStatusHandler(className, config) {\n  let lastPromise = Promise.resolve();\n  const auth = Auth.master(config);\n  function create(object) {\n    lastPromise = lastPromise.then(() => {\n      return rest.create(config, auth, className, object)\n        .then(({ response }) => {\n          // merge the objects\n          return Promise.resolve(Object.assign({}, object, response));\n        });\n    });\n    return lastPromise;\n  }\n\n  function update(where, object) {\n    // TODO: when we have updateWhere, use that for proper interfacing\n    lastPromise = lastPromise.then(() => {\n      return rest.update(config, auth, className, { objectId: where.objectId }, object)\n        .then(({ response }) => {\n          // merge the objects\n          return Promise.resolve(Object.assign({}, object, response));\n        });\n    });\n    return lastPromise;\n  }\n\n  return Object.freeze({\n    create,\n    update\n  })\n}\n\nexport function jobStatusHandler(config) {\n  let jobStatus;\n  const objectId = newObjectId(config.objectIdSize);\n  const database = config.database;\n  const handler = statusHandler(JOB_STATUS_COLLECTION, database);\n  const setRunning = function(jobName, params) {\n    const now = new Date();\n    jobStatus = {\n      objectId,\n      jobName,\n      params,\n      status: 'running',\n      source: 'api',\n      createdAt: now,\n      // lockdown!\n      ACL: {}\n    }\n\n    return handler.create(jobStatus);\n  }\n\n  const setMessage = function(message) {\n    if (!message || typeof message !== 'string') {\n      return Promise.resolve();\n    }\n    return handler.update({ objectId }, { message });\n  }\n\n  const setSucceeded = function(message) {\n    return setFinalStatus('succeeded', message);\n  }\n\n  const setFailed = function(message) {\n    return setFinalStatus('failed', message);\n  }\n\n  const setFinalStatus = function(status, message = undefined) {\n    const finishedAt = new Date();\n    const update = { status, finishedAt };\n    if (message && typeof message === 'string') {\n      update.message = message;\n    }\n    return handler.update({ objectId }, update);\n  }\n\n  return Object.freeze({\n    setRunning,\n    setSucceeded,\n    setMessage,\n    setFailed\n  });\n}\n\nexport function pushStatusHandler(config, existingObjectId) {\n\n  let pushStatus;\n  const database = config.database;\n  const handler = restStatusHandler(PUSH_STATUS_COLLECTION, config);\n  let objectId = existingObjectId;\n  const setInitial = function(body = {}, where, options = {source: 'rest'}) {\n    const now = new Date();\n    let pushTime = now.toISOString();\n    let status = 'pending';\n    if (body.hasOwnProperty('push_time')) {\n      if (config.hasPushScheduledSupport) {\n        pushTime = body.push_time;\n        status = 'scheduled';\n      } else {\n        logger.warn('Trying to schedule a push while server is not configured.');\n        logger.warn('Push will be sent immediately');\n      }\n    }\n\n    const data =  body.data || {};\n    const payloadString = JSON.stringify(data);\n    let pushHash;\n    if (typeof data.alert === 'string') {\n      pushHash = md5Hash(data.alert);\n    } else if (typeof data.alert === 'object') {\n      pushHash = md5Hash(JSON.stringify(data.alert));\n    } else {\n      pushHash = 'd41d8cd98f00b204e9800998ecf8427e';\n    }\n    const object = {\n      pushTime,\n      query: JSON.stringify(where),\n      payload: payloadString,\n      source: options.source,\n      title: options.title,\n      expiry: body.expiration_time,\n      expiration_interval: body.expiration_interval,\n      status: status,\n      numSent: 0,\n      pushHash,\n      // lockdown!\n      ACL: {}\n    }\n    return handler.create(object).then((result) => {\n      objectId = result.objectId;\n      pushStatus = {\n        objectId\n      };\n      return Promise.resolve(pushStatus);\n    });\n  }\n\n  const setRunning = function(batches) {\n    logger.verbose(`_PushStatus ${objectId}: sending push to installations with %d batches`, batches);\n    return handler.update(\n      {\n        status:\"pending\",\n        objectId: objectId\n      },\n      {\n        status: \"running\",\n        count: batches\n      }\n    );\n  }\n\n  const trackSent = function(results, UTCOffset, cleanupInstallations = process.env.PARSE_SERVER_CLEANUP_INVALID_INSTALLATIONS) {\n    const update = {\n      numSent: 0,\n      numFailed: 0\n    };\n    const devicesToRemove = [];\n    if (Array.isArray(results)) {\n      results = flatten(results);\n      results.reduce((memo, result) => {\n        // Cannot handle that\n        if (!result || !result.device || !result.device.deviceType) {\n          return memo;\n        }\n        const deviceType = result.device.deviceType;\n        const key = result.transmitted ? `sentPerType.${deviceType}` : `failedPerType.${deviceType}`;\n        memo[key] = incrementOp(memo, key);\n        if (typeof UTCOffset !== 'undefined') {\n          const offsetKey = result.transmitted ? `sentPerUTCOffset.${UTCOffset}` : `failedPerUTCOffset.${UTCOffset}`;\n          memo[offsetKey] = incrementOp(memo, offsetKey);\n        }\n        if (result.transmitted) {\n          memo.numSent++;\n        } else {\n          if (result && result.response && result.response.error && result.device && result.device.deviceToken) {\n            const token = result.device.deviceToken;\n            const error = result.response.error;\n            // GCM errors\n            if (error === 'NotRegistered' || error === 'InvalidRegistration') {\n              devicesToRemove.push(token);\n            }\n            // APNS errors\n            if (error === 'Unregistered' || error === 'BadDeviceToken') {\n              devicesToRemove.push(token);\n            }\n          }\n          memo.numFailed++;\n        }\n        return memo;\n      }, update);\n    }\n\n    logger.verbose(`_PushStatus ${objectId}: sent push! %d success, %d failures`, update.numSent, update.numFailed);\n    logger.verbose(`_PushStatus ${objectId}: needs cleanup`, { devicesToRemove });\n    ['numSent', 'numFailed'].forEach((key) => {\n      if (update[key] > 0) {\n        update[key] = {\n          __op: 'Increment',\n          amount: update[key]\n        };\n      } else {\n        delete update[key];\n      }\n    });\n\n    if (devicesToRemove.length > 0 && cleanupInstallations) {\n      logger.info(`Removing device tokens on ${devicesToRemove.length} _Installations`);\n      database.update('_Installation', { deviceToken: { '$in': devicesToRemove }}, { deviceToken: {\"__op\": \"Delete\"} }, {\n        acl: undefined,\n        many: true\n      });\n    }\n\n    // indicate this batch is complete\n    incrementOp(update, 'count', -1);\n\n    return handler.update({ objectId }, update).then((res) => {\n      if (res && res.count === 0) {\n        return this.complete();\n      }\n    })\n  }\n\n  const complete = function() {\n    return handler.update({ objectId }, {\n      status: 'succeeded',\n      count: {__op: 'Delete'}\n    });\n  }\n\n  const fail = function(err) {\n    if (typeof err === 'string') {\n      err = { message: err };\n    }\n    const update = {\n      errorMessage: err,\n      status: 'failed'\n    }\n    return handler.update({ objectId }, update);\n  }\n\n  const rval = {\n    setInitial,\n    setRunning,\n    trackSent,\n    complete,\n    fail\n  };\n\n  // define objectId to be dynamic\n  Object.defineProperty(rval, \"objectId\", {\n    get: () => objectId\n  });\n\n  return Object.freeze(rval);\n}\n"]} \ No newline at end of file diff --git a/lib/TestUtils.js b/lib/TestUtils.js index df58b7ceca..362a662a72 100644 --- a/lib/TestUtils.js +++ b/lib/TestUtils.js @@ -11,17 +11,21 @@ var _cache2 = _interopRequireDefault(_cache); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -//Used by tests -function destroyAllDataPermanently() { +/** + * Destroys all data in the database + * @param {boolean} fast set to true if it's ok to just drop objects and not indexes. + */ +function destroyAllDataPermanently(fast) { if (!process.env.TESTING) { throw 'Only supported in test environment'; } return Promise.all(Object.keys(_cache2.default.cache).map(appId => { const app = _cache2.default.get(appId); if (app.databaseController) { - return app.databaseController.deleteEverything(); + return app.databaseController.deleteEverything(fast); } else { return Promise.resolve(); } })); -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9UZXN0VXRpbHMuanMiXSwibmFtZXMiOlsiZGVzdHJveUFsbERhdGFQZXJtYW5lbnRseSIsImZhc3QiLCJwcm9jZXNzIiwiZW52IiwiVEVTVElORyIsIlByb21pc2UiLCJhbGwiLCJPYmplY3QiLCJrZXlzIiwiQXBwQ2FjaGUiLCJjYWNoZSIsIm1hcCIsImFwcElkIiwiYXBwIiwiZ2V0IiwiZGF0YWJhc2VDb250cm9sbGVyIiwiZGVsZXRlRXZlcnl0aGluZyIsInJlc29sdmUiXSwibWFwcGluZ3MiOiI7Ozs7O1FBTWdCQSx5QixHQUFBQSx5Qjs7QUFOaEI7Ozs7OztBQUVBOzs7O0FBSU8sU0FBU0EseUJBQVQsQ0FBbUNDLElBQW5DLEVBQXlDO0FBQzlDLE1BQUksQ0FBQ0MsUUFBUUMsR0FBUixDQUFZQyxPQUFqQixFQUEwQjtBQUN4QixVQUFNLG9DQUFOO0FBQ0Q7QUFDRCxTQUFPQyxRQUFRQyxHQUFSLENBQVlDLE9BQU9DLElBQVAsQ0FBWUMsZ0JBQVNDLEtBQXJCLEVBQTRCQyxHQUE1QixDQUFnQ0MsU0FBUztBQUMxRCxVQUFNQyxNQUFNSixnQkFBU0ssR0FBVCxDQUFhRixLQUFiLENBQVo7QUFDQSxRQUFJQyxJQUFJRSxrQkFBUixFQUE0QjtBQUMxQixhQUFPRixJQUFJRSxrQkFBSixDQUF1QkMsZ0JBQXZCLENBQXdDZixJQUF4QyxDQUFQO0FBQ0QsS0FGRCxNQUVPO0FBQ0wsYUFBT0ksUUFBUVksT0FBUixFQUFQO0FBQ0Q7QUFDRixHQVBrQixDQUFaLENBQVA7QUFRRCIsImZpbGUiOiJUZXN0VXRpbHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgQXBwQ2FjaGUgZnJvbSAnLi9jYWNoZSc7XG5cbi8qKlxuICogRGVzdHJveXMgYWxsIGRhdGEgaW4gdGhlIGRhdGFiYXNlXG4gKiBAcGFyYW0ge2Jvb2xlYW59IGZhc3Qgc2V0IHRvIHRydWUgaWYgaXQncyBvayB0byBqdXN0IGRyb3Agb2JqZWN0cyBhbmQgbm90IGluZGV4ZXMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZXN0cm95QWxsRGF0YVBlcm1hbmVudGx5KGZhc3QpIHtcbiAgaWYgKCFwcm9jZXNzLmVudi5URVNUSU5HKSB7XG4gICAgdGhyb3cgJ09ubHkgc3VwcG9ydGVkIGluIHRlc3QgZW52aXJvbm1lbnQnO1xuICB9XG4gIHJldHVybiBQcm9taXNlLmFsbChPYmplY3Qua2V5cyhBcHBDYWNoZS5jYWNoZSkubWFwKGFwcElkID0+IHtcbiAgICBjb25zdCBhcHAgPSBBcHBDYWNoZS5nZXQoYXBwSWQpO1xuICAgIGlmIChhcHAuZGF0YWJhc2VDb250cm9sbGVyKSB7XG4gICAgICByZXR1cm4gYXBwLmRhdGFiYXNlQ29udHJvbGxlci5kZWxldGVFdmVyeXRoaW5nKGZhc3QpO1xuICAgIH0gZWxzZSB7XG4gICAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKCk7XG4gICAgfVxuICB9KSk7XG59XG4iXX0= \ No newline at end of file diff --git a/lib/batch.js b/lib/batch.js index 1d95e529c0..fa94002648 100644 --- a/lib/batch.js +++ b/lib/batch.js @@ -95,4 +95,5 @@ function handleBatch(router, req) { module.exports = { mountOnto, makeBatchRoutingPathFunction -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/batch.js"],"names":["Parse","require","url","path","batchPath","mountOnto","router","route","req","handleBatch","parseURL","URL","parse","undefined","makeBatchRoutingPathFunction","originalUrl","serverURL","publicServerURL","apiPrefixLength","length","apiPrefix","slice","makeRoutablePath","requestPath","Error","INVALID_JSON","posix","join","localPath","publicPath","newPath","Array","isArray","body","requests","endsWith","config","promises","map","restRequest","routablePath","request","auth","info","tryRouteRequest","method","then","response","success","error","code","message","Promise","all","results","module","exports"],"mappings":"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","file":"batch.js","sourcesContent":["const Parse = require('parse/node').Parse;\nconst url = require('url');\nconst path = require('path');\n// These methods handle batch requests.\nconst batchPath = '/batch';\n\n// Mounts a batch-handler onto a PromiseRouter.\nfunction mountOnto(router) {\n  router.route('POST', batchPath, (req) => {\n    return handleBatch(router, req);\n  });\n}\n\nfunction parseURL(URL) {\n  if (typeof URL === 'string') {\n    return url.parse(URL)\n  }\n  return undefined;\n}\n\nfunction makeBatchRoutingPathFunction(originalUrl, serverURL, publicServerURL) {\n  serverURL = serverURL ? parseURL(serverURL) : undefined;\n  publicServerURL = publicServerURL ? parseURL(publicServerURL) : undefined;\n\n  const apiPrefixLength = originalUrl.length - batchPath.length;\n  let apiPrefix = originalUrl.slice(0, apiPrefixLength);\n\n  const makeRoutablePath = function(requestPath) {\n    // The routablePath is the path minus the api prefix\n    if (requestPath.slice(0, apiPrefix.length) != apiPrefix) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_JSON,\n        'cannot route batch path ' + requestPath);\n    }\n    return path.posix.join('/', requestPath.slice(apiPrefix.length));\n  }\n\n  if (serverURL && publicServerURL\n        && (serverURL.path != publicServerURL.path)) {\n    const localPath = serverURL.path;\n    const publicPath = publicServerURL.path;\n    // Override the api prefix\n    apiPrefix = localPath;\n    return function(requestPath) {\n      // Build the new path by removing the public path\n      // and joining with the local path\n      const newPath = path.posix.join('/', localPath, '/' , requestPath.slice(publicPath.length));\n      // Use the method for local routing\n      return makeRoutablePath(newPath);\n    }\n  }\n\n  return makeRoutablePath;\n}\n\n// Returns a promise for a {response} object.\n// TODO: pass along auth correctly\nfunction handleBatch(router, req) {\n  if (!Array.isArray(req.body.requests)) {\n    throw new Parse.Error(Parse.Error.INVALID_JSON,\n      'requests must be an array');\n  }\n\n  // The batch paths are all from the root of our domain.\n  // That means they include the API prefix, that the API is mounted\n  // to. However, our promise router does not route the api prefix. So\n  // we need to figure out the API prefix, so that we can strip it\n  // from all the subrequests.\n  if (!req.originalUrl.endsWith(batchPath)) {\n    throw 'internal routing problem - expected url to end with batch';\n  }\n\n  const makeRoutablePath = makeBatchRoutingPathFunction(req.originalUrl, req.config.serverURL, req.config.publicServerURL);\n\n  const promises = req.body.requests.map((restRequest) => {\n    const routablePath = makeRoutablePath(restRequest.path);\n    // Construct a request that we can send to a handler\n    const request = {\n      body: restRequest.body,\n      config: req.config,\n      auth: req.auth,\n      info: req.info\n    };\n\n    return router.tryRouteRequest(restRequest.method, routablePath, request).then((response) => {\n      return {success: response.response};\n    }, (error) => {\n      return {error: {code: error.code, error: error.message}};\n    });\n  });\n\n  return Promise.all(promises).then((results) => {\n    return {response: results};\n  });\n}\n\nmodule.exports = {\n  mountOnto,\n  makeBatchRoutingPathFunction\n};\n"]} \ No newline at end of file diff --git a/lib/cache.js b/lib/cache.js index 51641150c3..92644217c4 100644 --- a/lib/cache.js +++ b/lib/cache.js @@ -8,4 +8,5 @@ exports.AppCache = undefined; var _InMemoryCache = require('./Adapters/Cache/InMemoryCache'); var AppCache = exports.AppCache = new _InMemoryCache.InMemoryCache({ ttl: NaN }); -exports.default = AppCache; \ No newline at end of file +exports.default = AppCache; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jYWNoZS5qcyJdLCJuYW1lcyI6WyJBcHBDYWNoZSIsIkluTWVtb3J5Q2FjaGUiLCJ0dGwiLCJOYU4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQTs7QUFFTyxJQUFJQSw4QkFBVyxJQUFJQyw0QkFBSixDQUFrQixFQUFDQyxLQUFLQyxHQUFOLEVBQWxCLENBQWY7a0JBQ1FILFEiLCJmaWxlIjoiY2FjaGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luTWVtb3J5Q2FjaGV9IGZyb20gJy4vQWRhcHRlcnMvQ2FjaGUvSW5NZW1vcnlDYWNoZSc7XG5cbmV4cG9ydCB2YXIgQXBwQ2FjaGUgPSBuZXcgSW5NZW1vcnlDYWNoZSh7dHRsOiBOYU59KTtcbmV4cG9ydCBkZWZhdWx0IEFwcENhY2hlO1xuIl19 \ No newline at end of file diff --git a/lib/cli/definitions/parse-live-query-server.js b/lib/cli/definitions/parse-live-query-server.js index 094e37ca72..c054a8d9cf 100644 --- a/lib/cli/definitions/parse-live-query-server.js +++ b/lib/cli/definitions/parse-live-query-server.js @@ -4,4 +4,5 @@ Object.defineProperty(exports, "__esModule", { value: true }); const LiveQueryServerOptions = require('../../Options/Definitions').LiveQueryServerOptions; -exports.default = LiveQueryServerOptions; \ No newline at end of file +exports.default = LiveQueryServerOptions; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvZGVmaW5pdGlvbnMvcGFyc2UtbGl2ZS1xdWVyeS1zZXJ2ZXIuanMiXSwibmFtZXMiOlsiTGl2ZVF1ZXJ5U2VydmVyT3B0aW9ucyIsInJlcXVpcmUiXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsTUFBTUEseUJBQXlCQyxRQUFRLDJCQUFSLEVBQXFDRCxzQkFBcEU7a0JBQ2VBLHNCIiwiZmlsZSI6InBhcnNlLWxpdmUtcXVlcnktc2VydmVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgTGl2ZVF1ZXJ5U2VydmVyT3B0aW9ucyA9IHJlcXVpcmUoJy4uLy4uL09wdGlvbnMvRGVmaW5pdGlvbnMnKS5MaXZlUXVlcnlTZXJ2ZXJPcHRpb25zO1xuZXhwb3J0IGRlZmF1bHQgTGl2ZVF1ZXJ5U2VydmVyT3B0aW9ucztcbiJdfQ== \ No newline at end of file diff --git a/lib/cli/definitions/parse-server.js b/lib/cli/definitions/parse-server.js index f9dbfe85ac..c88be41cfd 100644 --- a/lib/cli/definitions/parse-server.js +++ b/lib/cli/definitions/parse-server.js @@ -4,4 +4,5 @@ Object.defineProperty(exports, "__esModule", { value: true }); const ParseServerDefinitions = require('../../Options/Definitions').ParseServerOptions; -exports.default = ParseServerDefinitions; \ No newline at end of file +exports.default = ParseServerDefinitions; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvZGVmaW5pdGlvbnMvcGFyc2Utc2VydmVyLmpzIl0sIm5hbWVzIjpbIlBhcnNlU2VydmVyRGVmaW5pdGlvbnMiLCJyZXF1aXJlIiwiUGFyc2VTZXJ2ZXJPcHRpb25zIl0sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE1BQU1BLHlCQUF5QkMsUUFBUSwyQkFBUixFQUFxQ0Msa0JBQXBFO2tCQUNlRixzQiIsImZpbGUiOiJwYXJzZS1zZXJ2ZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBQYXJzZVNlcnZlckRlZmluaXRpb25zID0gcmVxdWlyZSgnLi4vLi4vT3B0aW9ucy9EZWZpbml0aW9ucycpLlBhcnNlU2VydmVyT3B0aW9ucztcbmV4cG9ydCBkZWZhdWx0IFBhcnNlU2VydmVyRGVmaW5pdGlvbnM7XG4iXX0= \ No newline at end of file diff --git a/lib/cli/parse-live-query-server.js b/lib/cli/parse-live-query-server.js index 4adcd0ea43..327821e629 100644 --- a/lib/cli/parse-live-query-server.js +++ b/lib/cli/parse-live-query-server.js @@ -18,4 +18,5 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de logOptions(); _index.ParseServer.createLiveQueryServer(undefined, options); } -}); \ No newline at end of file +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGkvcGFyc2UtbGl2ZS1xdWVyeS1zZXJ2ZXIuanMiXSwibmFtZXMiOlsiZGVmaW5pdGlvbnMiLCJzdGFydCIsInByb2dyYW0iLCJvcHRpb25zIiwibG9nT3B0aW9ucyIsIlBhcnNlU2VydmVyIiwiY3JlYXRlTGl2ZVF1ZXJ5U2VydmVyIiwidW5kZWZpbmVkIl0sIm1hcHBpbmdzIjoiOztBQUFBOzs7O0FBQ0E7Ozs7QUFDQTs7OztBQUVBLHNCQUFPO0FBQ0xBLDZDQURLO0FBRUxDLFNBQU8sVUFBU0MsT0FBVCxFQUFrQkMsT0FBbEIsRUFBMkJDLFVBQTNCLEVBQXVDO0FBQzVDQTtBQUNBQyx1QkFBWUMscUJBQVosQ0FBa0NDLFNBQWxDLEVBQTZDSixPQUE3QztBQUNEO0FBTEksQ0FBUCIsImZpbGUiOiJwYXJzZS1saXZlLXF1ZXJ5LXNlcnZlci5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBkZWZpbml0aW9ucyBmcm9tICcuL2RlZmluaXRpb25zL3BhcnNlLWxpdmUtcXVlcnktc2VydmVyJztcbmltcG9ydCBydW5uZXIgZnJvbSAnLi91dGlscy9ydW5uZXInO1xuaW1wb3J0IHsgUGFyc2VTZXJ2ZXIgfSBmcm9tICcuLi9pbmRleCc7XG5cbnJ1bm5lcih7XG4gIGRlZmluaXRpb25zLFxuICBzdGFydDogZnVuY3Rpb24ocHJvZ3JhbSwgb3B0aW9ucywgbG9nT3B0aW9ucykge1xuICAgIGxvZ09wdGlvbnMoKTtcbiAgICBQYXJzZVNlcnZlci5jcmVhdGVMaXZlUXVlcnlTZXJ2ZXIodW5kZWZpbmVkLCBvcHRpb25zKTtcbiAgfVxufSlcbiJdfQ== \ No newline at end of file diff --git a/lib/cli/parse-server.js b/lib/cli/parse-server.js index 125396c70c..c3430c1de2 100755 --- a/lib/cli/parse-server.js +++ b/lib/cli/parse-server.js @@ -95,4 +95,5 @@ const help = function () { } }); -/* eslint-enable no-console */ \ No newline at end of file +/* eslint-enable no-console */ +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/cli/utils/commander.js b/lib/cli/utils/commander.js index 3059e45614..251df935cd 100644 --- a/lib/cli/utils/commander.js +++ b/lib/cli/utils/commander.js @@ -137,4 +137,5 @@ _commander.Command.prototype.getOptions = function () { }; exports.default = new _commander.Command(); -/* eslint-enable no-console */ \ No newline at end of file +/* eslint-enable no-console */ +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/cli/utils/commander.js"],"names":["_definitions","_reverseDefinitions","_defaults","Command","prototype","loadDefinitions","definitions","Object","keys","reduce","program","opt","additionalOptions","required","option","help","action","object","key","value","env","defs","default","on","console","log","forEach","parseEnvironment","options","originalKey","parseConfigFile","args","length","jsonPath","path","resolve","jsonConfig","require","apps","setValuesIfNeeded","hasOwnProperty","_parse","parse","envOptions","fromFile","getOptions"],"mappings":"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","file":"commander.js","sourcesContent":["/* eslint-disable no-console */\nimport { Command } from 'commander';\nimport path from 'path';\nlet _definitions;\nlet _reverseDefinitions;\nlet _defaults;\n\nCommand.prototype.loadDefinitions = function(definitions) {\n  _definitions = definitions;\n\n  Object.keys(definitions).reduce((program, opt) => {\n    if (typeof definitions[opt] == \"object\") {\n      const additionalOptions = definitions[opt];\n      if (additionalOptions.required === true) {\n        return program.option(`--${opt} <${opt}>`, additionalOptions.help, additionalOptions.action);\n      } else {\n        return program.option(`--${opt} [${opt}]`, additionalOptions.help, additionalOptions.action);\n      }\n    }\n    return program.option(`--${opt} [${opt}]`);\n  }, this);\n\n  _reverseDefinitions = Object.keys(definitions).reduce((object, key) => {\n    let value = definitions[key];\n    if (typeof value == \"object\") {\n      value = value.env;\n    }\n    if (value) {\n      object[value] = key;\n    }\n    return object;\n  }, {});\n\n  _defaults = Object.keys(definitions).reduce((defs, opt) => {\n    if(_definitions[opt].default) {\n      defs[opt] = _definitions[opt].default;\n    }\n    return defs;\n  }, {});\n\n  /* istanbul ignore next */\n  this.on('--help', function(){\n    console.log('  Configure From Environment:');\n    console.log('');\n    Object.keys(_reverseDefinitions).forEach((key) => {\n      console.log(`    $ ${key}='${_reverseDefinitions[key]}'`);\n    });\n    console.log('');\n  });\n};\n\nfunction parseEnvironment(env = {}) {\n  return Object.keys(_reverseDefinitions).reduce((options, key) => {\n    if (env[key]) {\n      const originalKey = _reverseDefinitions[key];\n      let action = (option) => (option);\n      if (typeof _definitions[originalKey] === \"object\") {\n        action = _definitions[originalKey].action || action;\n      }\n      options[_reverseDefinitions[key]] = action(env[key]);\n    }\n    return options;\n  }, {});\n}\n\nfunction parseConfigFile(program) {\n  let options = {};\n  if (program.args.length > 0) {\n    let jsonPath = program.args[0];\n    jsonPath = path.resolve(jsonPath);\n    const jsonConfig = require(jsonPath);\n    if (jsonConfig.apps) {\n      if (jsonConfig.apps.length > 1) {\n        throw 'Multiple apps are not supported';\n      }\n      options = jsonConfig.apps[0];\n    } else {\n      options = jsonConfig;\n    }\n    Object.keys(options).forEach((key) => {\n      const value = options[key];\n      if (!_definitions[key]) {\n        throw `error: unknown option ${key}`;\n      }\n      const action = _definitions[key].action;\n      if (action) {\n        options[key] = action(value);\n      }\n    });\n    console.log(`Configuration loaded from ${jsonPath}`)\n  }\n  return options;\n}\n\nCommand.prototype.setValuesIfNeeded = function(options) {\n  Object.keys(options).forEach((key) => {\n    if (!this.hasOwnProperty(key)) {\n      this[key] = options[key];\n    }\n  });\n};\n\nCommand.prototype._parse = Command.prototype.parse;\n\nCommand.prototype.parse = function(args, env) {\n  this._parse(args);\n  // Parse the environment first\n  const envOptions = parseEnvironment(env);\n  const fromFile = parseConfigFile(this);\n  // Load the env if not passed from command line\n  this.setValuesIfNeeded(envOptions);\n  // Load from file to override\n  this.setValuesIfNeeded(fromFile);\n  // Last set the defaults\n  this.setValuesIfNeeded(_defaults);\n};\n\nCommand.prototype.getOptions = function() {\n  return Object.keys(_definitions).reduce((options, key) => {\n    if (typeof this[key] !== 'undefined') {\n      options[key] = this[key];\n    }\n    return options;\n  }, {});\n};\n\nexport default new Command();\n/* eslint-enable no-console */\n"]} \ No newline at end of file diff --git a/lib/cli/utils/runner.js b/lib/cli/utils/runner.js index 0f38ab9e2e..3775f3eb2d 100644 --- a/lib/cli/utils/runner.js +++ b/lib/cli/utils/runner.js @@ -50,4 +50,5 @@ function logStartupOptions(options) { console.log(`${key}: ${value}`); /* eslint-enable no-console */ } -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/cloud-code/HTTPResponse.js b/lib/cloud-code/HTTPResponse.js index 47fd6e9d44..f44701e71d 100644 --- a/lib/cloud-code/HTTPResponse.js +++ b/lib/cloud-code/HTTPResponse.js @@ -53,4 +53,5 @@ class HTTPResponse { }); } } -exports.default = HTTPResponse; \ No newline at end of file +exports.default = HTTPResponse; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/cloud-code/Parse.Cloud.js b/lib/cloud-code/Parse.Cloud.js index f33baa9116..ab85c206a4 100644 --- a/lib/cloud-code/Parse.Cloud.js +++ b/lib/cloud-code/Parse.Cloud.js @@ -69,4 +69,5 @@ ParseCloud.useMasterKey = () => { ParseCloud.httpRequest = require("./httpRequest"); -module.exports = ParseCloud; \ No newline at end of file +module.exports = ParseCloud; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/cloud-code/httpRequest.js b/lib/cloud-code/httpRequest.js index 64188f20dc..f72234e262 100644 --- a/lib/cloud-code/httpRequest.js +++ b/lib/cloud-code/httpRequest.js @@ -98,4 +98,5 @@ module.exports = function (options) { return promise; }; -module.exports.encodeBody = encodeBody; \ No newline at end of file +module.exports.encodeBody = encodeBody; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/cryptoUtils.js b/lib/cryptoUtils.js index 1eae0aab4c..dbe462a569 100644 --- a/lib/cryptoUtils.js +++ b/lib/cryptoUtils.js @@ -55,4 +55,5 @@ function newToken() { function md5Hash(string) { return (0, _crypto.createHash)('md5').update(string).digest('hex'); -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/defaults.js b/lib/defaults.js index 2fadaeaee0..e9e7fc83ca 100644 --- a/lib/defaults.js +++ b/lib/defaults.js @@ -40,4 +40,5 @@ const computedDefaults = { }; exports.default = Object.assign({}, DefinitionDefaults, computedDefaults); -const DefaultMongoURI = exports.DefaultMongoURI = DefinitionDefaults.databaseURI; \ No newline at end of file +const DefaultMongoURI = exports.DefaultMongoURI = DefinitionDefaults.databaseURI; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/deprecated.js b/lib/deprecated.js index f808c611c6..39b1ef5b00 100644 --- a/lib/deprecated.js +++ b/lib/deprecated.js @@ -8,4 +8,5 @@ function useExternal(name, moduleName) { return function () { throw `${name} is not provided by parse-server anymore; please install ${moduleName}`; }; -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9kZXByZWNhdGVkLmpzIl0sIm5hbWVzIjpbInVzZUV4dGVybmFsIiwibmFtZSIsIm1vZHVsZU5hbWUiXSwibWFwcGluZ3MiOiI7Ozs7O1FBQWdCQSxXLEdBQUFBLFc7QUFBVCxTQUFTQSxXQUFULENBQXFCQyxJQUFyQixFQUEyQkMsVUFBM0IsRUFBdUM7QUFDNUMsU0FBTyxZQUFXO0FBQ2hCLFVBQU8sR0FBRUQsSUFBSyw0REFBMkRDLFVBQVcsRUFBcEY7QUFDRCxHQUZEO0FBR0QiLCJmaWxlIjoiZGVwcmVjYXRlZC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiB1c2VFeHRlcm5hbChuYW1lLCBtb2R1bGVOYW1lKSB7XG4gIHJldHVybiBmdW5jdGlvbigpIHtcbiAgICB0aHJvdyBgJHtuYW1lfSBpcyBub3QgcHJvdmlkZWQgYnkgcGFyc2Utc2VydmVyIGFueW1vcmU7IHBsZWFzZSBpbnN0YWxsICR7bW9kdWxlTmFtZX1gO1xuICB9XG59XG4iXX0= \ No newline at end of file diff --git a/lib/index.js b/lib/index.js index b3ba2ad882..2b088a859a 100644 --- a/lib/index.js +++ b/lib/index.js @@ -74,4 +74,5 @@ exports.RedisCacheAdapter = _RedisCacheAdapter2.default; exports.LRUCacheAdapter = _LRUCache2.default; exports.TestUtils = TestUtils; exports.PushWorker = _PushWorker.PushWorker; -exports.ParseServer = _ParseServer; \ No newline at end of file +exports.ParseServer = _ParseServer; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/logger.js b/lib/logger.js index 1f9e6dea5e..1513a6a52c 100644 --- a/lib/logger.js +++ b/lib/logger.js @@ -44,4 +44,5 @@ Object.defineProperty(module.exports, 'default', { // for: `import { logger } from './logger'` Object.defineProperty(module.exports, 'logger', { get: getLogger -}); \ No newline at end of file +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9sb2dnZXIuanMiXSwibmFtZXMiOlsic2V0TG9nZ2VyIiwiZ2V0TG9nZ2VyIiwiZGVmYXVsdExvZ2dlciIsIm9wdGlvbnMiLCJsb2dzRm9sZGVyIiwiZGVmYXVsdHMiLCJqc29uTG9ncyIsInZlcmJvc2UiLCJzaWxlbnQiLCJhZGFwdGVyIiwiV2luc3RvbkxvZ2dlckFkYXB0ZXIiLCJMb2dnZXJDb250cm9sbGVyIiwibG9nZ2VyIiwiYUxvZ2dlciIsIk9iamVjdCIsImRlZmluZVByb3BlcnR5IiwibW9kdWxlIiwiZXhwb3J0cyIsImdldCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O1FBaUJnQkEsUyxHQUFBQSxTO1FBSUFDLFMsR0FBQUEsUzs7QUFwQmhCOzs7O0FBQ0E7O0FBQ0E7Ozs7QUFFQSxTQUFTQyxhQUFULEdBQXlCO0FBQ3ZCLFFBQU1DLFVBQVU7QUFDZEMsZ0JBQVlDLG1CQUFTRCxVQURQO0FBRWRFLGNBQVVELG1CQUFTQyxRQUZMO0FBR2RDLGFBQVNGLG1CQUFTRSxPQUhKO0FBSWRDLFlBQVFILG1CQUFTRyxNQUpILEVBQWhCO0FBS0EsUUFBTUMsVUFBVSxJQUFJQywwQ0FBSixDQUF5QlAsT0FBekIsQ0FBaEI7QUFDQSxTQUFPLElBQUlRLGtDQUFKLENBQXFCRixPQUFyQixFQUE4QixJQUE5QixFQUFvQ04sT0FBcEMsQ0FBUDtBQUNEOztBQUVELElBQUlTLFNBQVNWLGVBQWI7O0FBRU8sU0FBU0YsU0FBVCxDQUFtQmEsT0FBbkIsRUFBNEI7QUFDakNELFdBQVNDLE9BQVQ7QUFDRDs7QUFFTSxTQUFTWixTQUFULEdBQXFCO0FBQzFCLFNBQU9XLE1BQVA7QUFDRDs7QUFFRDtBQUNBRSxPQUFPQyxjQUFQLENBQXNCQyxPQUFPQyxPQUE3QixFQUFzQyxTQUF0QyxFQUFpRDtBQUMvQ0MsT0FBS2pCO0FBRDBDLENBQWpEOztBQUlBO0FBQ0FhLE9BQU9DLGNBQVAsQ0FBc0JDLE9BQU9DLE9BQTdCLEVBQXNDLFFBQXRDLEVBQWdEO0FBQzlDQyxPQUFLakI7QUFEeUMsQ0FBaEQiLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuaW1wb3J0IGRlZmF1bHRzIGZyb20gJy4vZGVmYXVsdHMnO1xuaW1wb3J0IHsgV2luc3RvbkxvZ2dlckFkYXB0ZXIgfSBmcm9tICcuL0FkYXB0ZXJzL0xvZ2dlci9XaW5zdG9uTG9nZ2VyQWRhcHRlcic7XG5pbXBvcnQgeyBMb2dnZXJDb250cm9sbGVyIH0gICAgIGZyb20gJy4vQ29udHJvbGxlcnMvTG9nZ2VyQ29udHJvbGxlcic7XG5cbmZ1bmN0aW9uIGRlZmF1bHRMb2dnZXIoKSB7XG4gIGNvbnN0IG9wdGlvbnMgPSB7XG4gICAgbG9nc0ZvbGRlcjogZGVmYXVsdHMubG9nc0ZvbGRlcixcbiAgICBqc29uTG9nczogZGVmYXVsdHMuanNvbkxvZ3MsXG4gICAgdmVyYm9zZTogZGVmYXVsdHMudmVyYm9zZSxcbiAgICBzaWxlbnQ6IGRlZmF1bHRzLnNpbGVudCB9O1xuICBjb25zdCBhZGFwdGVyID0gbmV3IFdpbnN0b25Mb2dnZXJBZGFwdGVyKG9wdGlvbnMpO1xuICByZXR1cm4gbmV3IExvZ2dlckNvbnRyb2xsZXIoYWRhcHRlciwgbnVsbCwgb3B0aW9ucyk7XG59XG5cbmxldCBsb2dnZXIgPSBkZWZhdWx0TG9nZ2VyKCk7XG5cbmV4cG9ydCBmdW5jdGlvbiBzZXRMb2dnZXIoYUxvZ2dlcikge1xuICBsb2dnZXIgPSBhTG9nZ2VyO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0TG9nZ2VyKCkge1xuICByZXR1cm4gbG9nZ2VyO1xufVxuXG4vLyBmb3I6IGBpbXBvcnQgbG9nZ2VyIGZyb20gJy4vbG9nZ2VyJ2Bcbk9iamVjdC5kZWZpbmVQcm9wZXJ0eShtb2R1bGUuZXhwb3J0cywgJ2RlZmF1bHQnLCB7XG4gIGdldDogZ2V0TG9nZ2VyXG59KTtcblxuLy8gZm9yOiBgaW1wb3J0IHsgbG9nZ2VyIH0gZnJvbSAnLi9sb2dnZXInYFxuT2JqZWN0LmRlZmluZVByb3BlcnR5KG1vZHVsZS5leHBvcnRzLCAnbG9nZ2VyJywge1xuICBnZXQ6IGdldExvZ2dlclxufSk7XG4iXX0= \ No newline at end of file diff --git a/lib/middlewares.js b/lib/middlewares.js index 4b336419f7..d24c026bd9 100644 --- a/lib/middlewares.js +++ b/lib/middlewares.js @@ -268,7 +268,7 @@ function allowCrossDomain(req, res, next) { res.header('Access-Control-Allow-Origin', '*'); res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS'); res.header('Access-Control-Allow-Headers', 'X-Parse-Master-Key, X-Parse-REST-API-Key, X-Parse-Javascript-Key, X-Parse-Application-Id, X-Parse-Client-Version, X-Parse-Session-Token, X-Requested-With, X-Parse-Revocable-Session, Content-Type, X-CSRF-Token'); - + res.header('Access-Control-Expose-Headers', 'X-Parse-Job-Status-Id, X-Parse-Push-Status-Id'); // intercept OPTIONS method if ('OPTIONS' == req.method) { res.sendStatus(200); @@ -304,6 +304,9 @@ function handleParseErrors(err, req, res, next) { res.status(httpStatus); res.json({ code: err.code, error: err.message }); _logger2.default.error(err.message, err); + if (req.config && req.config.enableExpressErrorHandler) { + next(err); + } } else if (err.status && err.message) { res.status(err.status); res.json({ error: err.message }); @@ -341,4 +344,5 @@ function promiseEnforceMasterKeyAccess(request) { function invalidRequest(req, res) { res.status(403); res.end('{"error":"unauthorized"}'); -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/middlewares.js"],"names":["handleParseHeaders","allowCrossDomain","allowMethodOverride","handleParseErrors","enforceMasterKeyAccess","promiseEnforceMasterKeyAccess","req","res","next","mountPathLength","originalUrl","length","url","mountPath","slice","mount","protocol","get","info","appId","sessionToken","masterKey","installationId","clientKey","javascriptKey","dotNetKey","restAPIKey","clientVersion","basicAuth","httpAuth","basicAuthAppId","AppCache","body","_noBody","fileViaJSON","Buffer","JSON","parse","_RevocableSession","_ApplicationId","_JavaScriptKey","_ClientVersion","_InstallationId","_SessionToken","_MasterKey","_ContentType","headers","invalidRequest","clientSDK","ClientSDK","fromString","base64","clientIp","getClientIp","app","config","Config","ip","masterKeyIps","indexOf","isMaster","auth","Auth","isReadOnlyMaster","readOnlyMasterKey","isReadOnly","keys","oneKeyConfigured","some","key","undefined","oneKeyMatches","Promise","resolve","then","getAuthForLegacySessionToken","getAuthForSessionToken","catch","error","Parse","Error","log","UNKNOWN_ERROR","split","connection","remoteAddress","socket","authorization","header","authPrefix","match","toLowerCase","encodedAuth","substring","credentials","decodeBase64","jsKeyPrefix","matchKey","str","toString","method","sendStatus","_method","originalMethod","err","httpStatus","code","INTERNAL_SERVER_ERROR","OBJECT_NOT_FOUND","status","json","message","enableExpressErrorHandler","stack","end","request"],"mappings":"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","file":"middlewares.js","sourcesContent":["import AppCache from './cache';\nimport log from './logger';\nimport Parse from 'parse/node';\nimport auth from './Auth';\nimport Config from './Config';\nimport ClientSDK from './ClientSDK';\n\n// Checks that the request is authorized for this app and checks user\n// auth too.\n// The bodyparser should run before this middleware.\n// Adds info to the request:\n// req.config - the Config for this app\n// req.auth - the Auth for this request\nexport function handleParseHeaders(req, res, next) {\n  var mountPathLength = req.originalUrl.length - req.url.length;\n  var mountPath = req.originalUrl.slice(0, mountPathLength);\n  var mount = req.protocol + '://' + req.get('host') + mountPath;\n\n  var info = {\n    appId: req.get('X-Parse-Application-Id'),\n    sessionToken: req.get('X-Parse-Session-Token'),\n    masterKey: req.get('X-Parse-Master-Key'),\n    installationId: req.get('X-Parse-Installation-Id'),\n    clientKey: req.get('X-Parse-Client-Key'),\n    javascriptKey: req.get('X-Parse-Javascript-Key'),\n    dotNetKey: req.get('X-Parse-Windows-Key'),\n    restAPIKey: req.get('X-Parse-REST-API-Key'),\n    clientVersion: req.get('X-Parse-Client-Version')\n  };\n\n  var basicAuth = httpAuth(req);\n\n  if (basicAuth) {\n    var basicAuthAppId = basicAuth.appId;\n    if (AppCache.get(basicAuthAppId)) {\n      info.appId = basicAuthAppId;\n      info.masterKey = basicAuth.masterKey || info.masterKey;\n      info.javascriptKey = basicAuth.javascriptKey || info.javascriptKey;\n    }\n  }\n\n  if (req.body) {\n    // Unity SDK sends a _noBody key which needs to be removed.\n    // Unclear at this point if action needs to be taken.\n    delete req.body._noBody;\n  }\n\n  var fileViaJSON = false;\n\n  if (!info.appId || !AppCache.get(info.appId)) {\n    // See if we can find the app id on the body.\n    if (req.body instanceof Buffer) {\n      // The only chance to find the app id is if this is a file\n      // upload that actually is a JSON body. So try to parse it.\n      req.body = JSON.parse(req.body);\n      fileViaJSON = true;\n    }\n\n    if (req.body) {\n      delete req.body._RevocableSession;\n    }\n\n    if (req.body &&\n      req.body._ApplicationId &&\n      AppCache.get(req.body._ApplicationId) &&\n      (!info.masterKey || AppCache.get(req.body._ApplicationId).masterKey === info.masterKey)\n    ) {\n      info.appId = req.body._ApplicationId;\n      info.javascriptKey = req.body._JavaScriptKey || '';\n      delete req.body._ApplicationId;\n      delete req.body._JavaScriptKey;\n      // TODO: test that the REST API formats generated by the other\n      // SDKs are handled ok\n      if (req.body._ClientVersion) {\n        info.clientVersion = req.body._ClientVersion;\n        delete req.body._ClientVersion;\n      }\n      if (req.body._InstallationId) {\n        info.installationId = req.body._InstallationId;\n        delete req.body._InstallationId;\n      }\n      if (req.body._SessionToken) {\n        info.sessionToken = req.body._SessionToken;\n        delete req.body._SessionToken;\n      }\n      if (req.body._MasterKey) {\n        info.masterKey = req.body._MasterKey;\n        delete req.body._MasterKey;\n      }\n      if (req.body._ContentType) {\n        req.headers['content-type'] = req.body._ContentType;\n        delete req.body._ContentType;\n      }\n    } else {\n      return invalidRequest(req, res);\n    }\n  }\n\n  if (info.clientVersion) {\n    info.clientSDK = ClientSDK.fromString(info.clientVersion);\n  }\n\n  if (fileViaJSON) {\n    // We need to repopulate req.body with a buffer\n    var base64 = req.body.base64;\n    req.body = new Buffer(base64, 'base64');\n  }\n\n  const clientIp = getClientIp(req);\n\n  info.app = AppCache.get(info.appId);\n  req.config = Config.get(info.appId, mount);\n  req.config.headers = req.headers || {};\n  req.config.ip = clientIp;\n  req.info = info;\n\n  if (info.masterKey && req.config.masterKeyIps && req.config.masterKeyIps.length !== 0 && req.config.masterKeyIps.indexOf(clientIp) === -1) {\n    return invalidRequest(req, res);\n  }\n\n  var isMaster = (info.masterKey === req.config.masterKey);\n\n  if (isMaster) {\n    req.auth = new auth.Auth({ config: req.config, installationId: info.installationId, isMaster: true });\n    next();\n    return;\n  }\n\n  var isReadOnlyMaster = (info.masterKey === req.config.readOnlyMasterKey);\n  if (typeof req.config.readOnlyMasterKey != 'undefined' && req.config.readOnlyMasterKey && isReadOnlyMaster) {\n    req.auth = new auth.Auth({ config: req.config, installationId: info.installationId, isMaster: true, isReadOnly: true });\n    next();\n    return;\n  }\n\n  // Client keys are not required in parse-server, but if any have been configured in the server, validate them\n  //  to preserve original behavior.\n  const keys = [\"clientKey\", \"javascriptKey\", \"dotNetKey\", \"restAPIKey\"];\n  const oneKeyConfigured = keys.some(function(key) {\n    return req.config[key] !== undefined;\n  });\n  const oneKeyMatches = keys.some(function(key){\n    return req.config[key] !== undefined && info[key] === req.config[key];\n  });\n\n  if (oneKeyConfigured && !oneKeyMatches) {\n    return invalidRequest(req, res);\n  }\n\n  if (req.url == \"/login\") {\n    delete info.sessionToken;\n  }\n\n  if (!info.sessionToken) {\n    req.auth = new auth.Auth({ config: req.config, installationId: info.installationId, isMaster: false });\n    next();\n    return;\n  }\n\n  return Promise.resolve().then(() => {\n    // handle the upgradeToRevocableSession path on it's own\n    if (info.sessionToken &&\n        req.url === '/upgradeToRevocableSession' &&\n        info.sessionToken.indexOf('r:') != 0) {\n      return auth.getAuthForLegacySessionToken({ config: req.config, installationId: info.installationId, sessionToken: info.sessionToken })\n    } else {\n      return auth.getAuthForSessionToken({ config: req.config, installationId: info.installationId, sessionToken: info.sessionToken })\n    }\n  }).then((auth) => {\n    if (auth) {\n      req.auth = auth;\n      next();\n    }\n  })\n    .catch((error) => {\n      if(error instanceof Parse.Error) {\n        next(error);\n        return;\n      }\n      else {\n        // TODO: Determine the correct error scenario.\n        log.error('error getting auth for sessionToken', error);\n        throw new Parse.Error(Parse.Error.UNKNOWN_ERROR, error);\n      }\n    });\n}\n\nfunction getClientIp(req){\n  if (req.headers['x-forwarded-for']) {\n    // try to get from x-forwared-for if it set (behind reverse proxy)\n    return req.headers['x-forwarded-for'].split(',')[0];\n  } else if (req.connection && req.connection.remoteAddress) {\n    // no proxy, try getting from connection.remoteAddress\n    return req.connection.remoteAddress;\n  } else if (req.socket) {\n    // try to get it from req.socket\n    return req.socket.remoteAddress;\n  } else if (req.connection && req.connection.socket) {\n    // try to get it form the connection.socket\n    return req.connection.socket.remoteAddress;\n  } else {\n    // if non above, fallback.\n    return req.ip;\n  }\n}\n\nfunction httpAuth(req) {\n  if (!(req.req || req).headers.authorization)\n    return ;\n\n  var header = (req.req || req).headers.authorization;\n  var appId, masterKey, javascriptKey;\n\n  // parse header\n  var authPrefix = 'basic ';\n\n  var match = header.toLowerCase().indexOf(authPrefix);\n\n  if (match == 0) {\n    var encodedAuth = header.substring(authPrefix.length, header.length);\n    var credentials = decodeBase64(encodedAuth).split(':');\n\n    if (credentials.length == 2) {\n      appId = credentials[0];\n      var key = credentials[1];\n\n      var jsKeyPrefix = 'javascript-key=';\n\n      var matchKey = key.indexOf(jsKeyPrefix)\n      if (matchKey == 0) {\n        javascriptKey = key.substring(jsKeyPrefix.length, key.length);\n      }\n      else {\n        masterKey = key;\n      }\n    }\n  }\n\n  return {appId: appId, masterKey: masterKey, javascriptKey: javascriptKey};\n}\n\nfunction decodeBase64(str) {\n  return new Buffer(str, 'base64').toString()\n}\n\nexport function allowCrossDomain(req, res, next) {\n  res.header('Access-Control-Allow-Origin', '*');\n  res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');\n  res.header('Access-Control-Allow-Headers', 'X-Parse-Master-Key, X-Parse-REST-API-Key, X-Parse-Javascript-Key, X-Parse-Application-Id, X-Parse-Client-Version, X-Parse-Session-Token, X-Requested-With, X-Parse-Revocable-Session, Content-Type, X-CSRF-Token');\n  res.header('Access-Control-Expose-Headers', 'X-Parse-Job-Status-Id, X-Parse-Push-Status-Id');\n  // intercept OPTIONS method\n  if ('OPTIONS' == req.method) {\n    res.sendStatus(200);\n  }\n  else {\n    next();\n  }\n}\n\nexport function allowMethodOverride(req, res, next) {\n  if (req.method === 'POST' && req.body._method) {\n    req.originalMethod = req.method;\n    req.method = req.body._method;\n    delete req.body._method;\n  }\n  next();\n}\n\nexport function handleParseErrors(err, req, res, next) {\n  if (err instanceof Parse.Error) {\n    let httpStatus;\n    // TODO: fill out this mapping\n    switch (err.code) {\n    case Parse.Error.INTERNAL_SERVER_ERROR:\n      httpStatus = 500;\n      break;\n    case Parse.Error.OBJECT_NOT_FOUND:\n      httpStatus = 404;\n      break;\n    default:\n      httpStatus = 400;\n    }\n\n    res.status(httpStatus);\n    res.json({ code: err.code, error: err.message });\n    log.error(err.message, err);\n    if (req.config && req.config.enableExpressErrorHandler) {\n      next(err);\n    }\n  } else if (err.status && err.message) {\n    res.status(err.status);\n    res.json({ error: err.message });\n    next(err);\n  } else {\n    log.error('Uncaught internal server error.', err, err.stack);\n    res.status(500);\n    res.json({\n      code: Parse.Error.INTERNAL_SERVER_ERROR,\n      message: 'Internal server error.'\n    });\n    next(err);\n  }\n\n}\n\nexport function enforceMasterKeyAccess(req, res, next) {\n  if (!req.auth.isMaster) {\n    res.status(403);\n    res.end('{\"error\":\"unauthorized: master key is required\"}');\n    return;\n  }\n  next();\n}\n\nexport function promiseEnforceMasterKeyAccess(request) {\n  if (!request.auth.isMaster) {\n    const error = new Error();\n    error.status = 403;\n    error.message = \"unauthorized: master key is required\";\n    throw error;\n  }\n  return Promise.resolve();\n}\n\nfunction invalidRequest(req, res) {\n  res.status(403);\n  res.end('{\"error\":\"unauthorized\"}');\n}\n"]} \ No newline at end of file diff --git a/lib/password.js b/lib/password.js index 729a07b272..763c292ade 100644 --- a/lib/password.js +++ b/lib/password.js @@ -26,4 +26,5 @@ function compare(password, hashedPassword) { module.exports = { hash: hash, compare: compare -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9wYXNzd29yZC5qcyJdLCJuYW1lcyI6WyJiY3J5cHQiLCJyZXF1aXJlIiwiZSIsImhhc2giLCJwYXNzd29yZCIsImNvbXBhcmUiLCJoYXNoZWRQYXNzd29yZCIsIlByb21pc2UiLCJyZXNvbHZlIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6Ijs7QUFBQTtBQUNBO0FBQ0EsSUFBSUEsU0FBU0MsUUFBUSxVQUFSLENBQWI7O0FBRUEsSUFBSTtBQUNGRCxXQUFTQyxRQUFRLFFBQVIsQ0FBVDtBQUNELENBRkQsQ0FFRSxPQUFNQyxDQUFOLEVBQVMsQ0FBUyxDQUFsQixDQUFXOztBQUViO0FBQ0EsU0FBU0MsSUFBVCxDQUFjQyxRQUFkLEVBQXdCO0FBQ3RCLFNBQU9KLE9BQU9HLElBQVAsQ0FBWUMsUUFBWixFQUFzQixFQUF0QixDQUFQO0FBQ0Q7O0FBRUQ7QUFDQTtBQUNBLFNBQVNDLE9BQVQsQ0FBaUJELFFBQWpCLEVBQTJCRSxjQUEzQixFQUEyQztBQUN6QztBQUNBLE1BQUksQ0FBQ0YsUUFBRCxJQUFhLENBQUNFLGNBQWxCLEVBQWtDO0FBQ2hDLFdBQU9DLFFBQVFDLE9BQVIsQ0FBZ0IsS0FBaEIsQ0FBUDtBQUNEO0FBQ0QsU0FBT1IsT0FBT0ssT0FBUCxDQUFlRCxRQUFmLEVBQXlCRSxjQUF6QixDQUFQO0FBQ0Q7O0FBRURHLE9BQU9DLE9BQVAsR0FBaUI7QUFDZlAsUUFBTUEsSUFEUztBQUVmRSxXQUFTQTtBQUZNLENBQWpCIiwiZmlsZSI6InBhc3N3b3JkLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVG9vbHMgZm9yIGVuY3J5cHRpbmcgYW5kIGRlY3J5cHRpbmcgcGFzc3dvcmRzLlxuLy8gQmFzaWNhbGx5IHByb21pc2UtZnJpZW5kbHkgd3JhcHBlcnMgZm9yIGJjcnlwdC5cbnZhciBiY3J5cHQgPSByZXF1aXJlKCdiY3J5cHRqcycpO1xuXG50cnkge1xuICBiY3J5cHQgPSByZXF1aXJlKCdiY3J5cHQnKTtcbn0gY2F0Y2goZSkgeyAvKiAqLyB9XG5cbi8vIFJldHVybnMgYSBwcm9taXNlIGZvciBhIGhhc2hlZCBwYXNzd29yZCBzdHJpbmcuXG5mdW5jdGlvbiBoYXNoKHBhc3N3b3JkKSB7XG4gIHJldHVybiBiY3J5cHQuaGFzaChwYXNzd29yZCwgMTApO1xufVxuXG4vLyBSZXR1cm5zIGEgcHJvbWlzZSBmb3Igd2hldGhlciB0aGlzIHBhc3N3b3JkIGNvbXBhcmVzIHRvIGVxdWFsIHRoaXNcbi8vIGhhc2hlZCBwYXNzd29yZC5cbmZ1bmN0aW9uIGNvbXBhcmUocGFzc3dvcmQsIGhhc2hlZFBhc3N3b3JkKSB7XG4gIC8vIENhbm5vdCBiY3J5cHQgY29tcGFyZSB3aGVuIG9uZSBpcyB1bmRlZmluZWRcbiAgaWYgKCFwYXNzd29yZCB8fCAhaGFzaGVkUGFzc3dvcmQpIHtcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKGZhbHNlKTtcbiAgfVxuICByZXR1cm4gYmNyeXB0LmNvbXBhcmUocGFzc3dvcmQsIGhhc2hlZFBhc3N3b3JkKTtcbn1cblxubW9kdWxlLmV4cG9ydHMgPSB7XG4gIGhhc2g6IGhhc2gsXG4gIGNvbXBhcmU6IGNvbXBhcmVcbn07XG4iXX0= \ No newline at end of file diff --git a/lib/requiredParameter.js b/lib/requiredParameter.js index 844b5a0749..2360480310 100644 --- a/lib/requiredParameter.js +++ b/lib/requiredParameter.js @@ -6,4 +6,5 @@ Object.defineProperty(exports, "__esModule", { exports.default = errorMessage => { throw errorMessage; -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9yZXF1aXJlZFBhcmFtZXRlci5qcyJdLCJuYW1lcyI6WyJlcnJvck1lc3NhZ2UiXSwibWFwcGluZ3MiOiI7Ozs7OztrQkFDZ0JBLFlBQUQsSUFBK0I7QUFBRSxRQUFNQSxZQUFOO0FBQW9CLEMiLCJmaWxlIjoicmVxdWlyZWRQYXJhbWV0ZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGZsb3cgKi9cbmV4cG9ydCBkZWZhdWx0IChlcnJvck1lc3NhZ2U6IHN0cmluZyk6IGFueSA9PiB7IHRocm93IGVycm9yTWVzc2FnZSB9XG4iXX0= \ No newline at end of file diff --git a/lib/rest.js b/lib/rest.js index ffe0e0326a..85df55ffbd 100644 --- a/lib/rest.js +++ b/lib/rest.js @@ -1,11 +1,5 @@ 'use strict'; -var _Auth = require('./Auth'); - -var _Auth2 = _interopRequireDefault(_Auth); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - // This file contains helpers for running operations in REST format. // The goal is that handlers that explicitly handle an express route // should just be shallow wrappers around things in this file, but @@ -17,7 +11,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de var Parse = require('parse/node').Parse; - var RestQuery = require('./RestQuery'); var RestWrite = require('./RestWrite'); var triggers = require('./triggers'); @@ -61,8 +54,8 @@ function del(config, auth, className, objectId) { throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad objectId'); } - if (className === '_User' && !auth.couldUpdateUserId(objectId)) { - throw new Parse.Error(Parse.Error.SESSION_MISSING, 'insufficient auth to delete user'); + if (className === '_User' && auth.isUnauthenticated()) { + throw new Parse.Error(Parse.Error.SESSION_MISSING, 'Insufficient auth to delete user'); } enforceRoleSecurity('delete', className, auth); @@ -73,13 +66,13 @@ function del(config, auth, className, objectId) { const hasTriggers = checkTriggers(className, config, ['beforeDelete', 'afterDelete']); const hasLiveQuery = checkLiveQuery(className, config); if (hasTriggers || hasLiveQuery || className == '_Session') { - return find(config, _Auth2.default.master(config), className, { objectId: objectId }).then(response => { + return new RestQuery(config, auth, className, { objectId }).forWrite().execute().then(response => { if (response && response.results && response.results.length) { const firstResult = response.results[0]; firstResult.className = className; if (className === '_Session' && !auth.isMaster) { if (!auth.user || firstResult.user.objectId !== auth.user.id) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } } var cacheAdapter = config.cacheController; @@ -114,6 +107,8 @@ function del(config, auth, className, objectId) { }, options); }).then(() => { return triggers.maybeRunTrigger(triggers.Types.afterDelete, auth, inflatedObject, null, config); + }).catch(error => { + handleSessionMissingError(error, className, auth); }); } @@ -134,20 +129,29 @@ function update(config, auth, className, restWhere, restObject, clientSDK) { const hasTriggers = checkTriggers(className, config, ['beforeSave', 'afterSave']); const hasLiveQuery = checkLiveQuery(className, config); if (hasTriggers || hasLiveQuery) { - return find(config, _Auth2.default.master(config), className, restWhere); + // Do not use find, as it runs the before finds + return new RestQuery(config, auth, className, restWhere).forWrite().execute(); } return Promise.resolve({}); - }).then(response => { + }).then(({ results }) => { var originalRestObject; - if (response && response.results && response.results.length) { - originalRestObject = response.results[0]; + if (results && results.length) { + originalRestObject = results[0]; } - - var write = new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK); - return write.execute(); + return new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK).execute(); + }).catch(error => { + handleSessionMissingError(error, className, auth); }); } +function handleSessionMissingError(error, className) { + // If we're trying to update a user without / with bad session token + if (className === '_User' && error.code === Parse.Error.OBJECT_NOT_FOUND) { + throw new Parse.Error(Parse.Error.SESSION_MISSING, 'Insufficient auth.'); + } + throw error; +} + const classesWithMasterOnlyAccess = ['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule']; // Disallowing access to the _Role collection except by master key function enforceRoleSecurity(method, className, auth) { @@ -177,4 +181,5 @@ module.exports = { find, get, update -}; \ No newline at end of file +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/rest.js"],"names":["Parse","require","RestQuery","RestWrite","triggers","checkTriggers","className","config","types","some","triggerType","getTrigger","Types","applicationId","checkLiveQuery","liveQueryController","hasLiveQuery","find","auth","restWhere","restOptions","clientSDK","enforceRoleSecurity","maybeRunQueryTrigger","beforeFind","then","result","query","execute","get","objectId","del","Error","INVALID_JSON","isUnauthenticated","SESSION_MISSING","inflatedObject","Promise","resolve","hasTriggers","forWrite","response","results","length","firstResult","isMaster","user","id","INVALID_SESSION_TOKEN","cacheAdapter","cacheController","sessionToken","Object","fromJSON","onAfterDelete","maybeRunTrigger","beforeDelete","OBJECT_NOT_FOUND","getUserRoles","options","acl","push","concat","userRoles","database","destroy","afterDelete","catch","error","handleSessionMissingError","create","restObject","write","update","originalRestObject","code","classesWithMasterOnlyAccess","method","OPERATION_FORBIDDEN","indexOf","isReadOnly","module","exports"],"mappings":"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","file":"rest.js","sourcesContent":["// This file contains helpers for running operations in REST format.\n// The goal is that handlers that explicitly handle an express route\n// should just be shallow wrappers around things in this file, but\n// these functions should not explicitly depend on the request\n// object.\n// This means that one of these handlers can support multiple\n// routes. That's useful for the routes that do really similar\n// things.\n\nvar Parse = require('parse/node').Parse;\n\nvar RestQuery = require('./RestQuery');\nvar RestWrite = require('./RestWrite');\nvar triggers = require('./triggers');\n\nfunction checkTriggers(className, config, types) {\n  return types.some((triggerType) => {\n    return triggers.getTrigger(className, triggers.Types[triggerType], config.applicationId);\n  });\n}\n\nfunction checkLiveQuery(className, config) {\n  return config.liveQueryController && config.liveQueryController.hasLiveQuery(className)\n}\n\n// Returns a promise for an object with optional keys 'results' and 'count'.\nfunction find(config, auth, className, restWhere, restOptions, clientSDK) {\n  enforceRoleSecurity('find', className, auth);\n  return triggers.maybeRunQueryTrigger(triggers.Types.beforeFind, className, restWhere, restOptions, config, auth).then((result) => {\n    restWhere = result.restWhere || restWhere;\n    restOptions = result.restOptions || restOptions;\n    const query = new RestQuery(config, auth, className, restWhere, restOptions, clientSDK);\n    return query.execute();\n  });\n}\n\n// get is just like find but only queries an objectId.\nconst get = (config, auth, className, objectId, restOptions, clientSDK) => {\n  var restWhere = { objectId };\n  enforceRoleSecurity('get', className, auth);\n  return triggers.maybeRunQueryTrigger(triggers.Types.beforeFind, className, restWhere, restOptions, config, auth, true).then((result) => {\n    restWhere = result.restWhere || restWhere;\n    restOptions = result.restOptions || restOptions;\n    const query = new RestQuery(config, auth, className, restWhere, restOptions, clientSDK);\n    return query.execute();\n  });\n}\n\n// Returns a promise that doesn't resolve to any useful value.\nfunction del(config, auth, className, objectId) {\n  if (typeof objectId !== 'string') {\n    throw new Parse.Error(Parse.Error.INVALID_JSON,\n      'bad objectId');\n  }\n\n  if (className === '_User' && auth.isUnauthenticated()) {\n    throw new Parse.Error(Parse.Error.SESSION_MISSING,\n      'Insufficient auth to delete user');\n  }\n\n  enforceRoleSecurity('delete', className, auth);\n\n  var inflatedObject;\n\n  return Promise.resolve().then(() => {\n    const hasTriggers = checkTriggers(className, config, ['beforeDelete', 'afterDelete']);\n    const hasLiveQuery = checkLiveQuery(className, config);\n    if (hasTriggers || hasLiveQuery || className == '_Session') {\n      return new RestQuery(config, auth, className, { objectId })\n        .forWrite()\n        .execute()\n        .then((response) => {\n          if (response && response.results && response.results.length) {\n            const firstResult = response.results[0];\n            firstResult.className = className;\n            if (className === '_Session' && !auth.isMaster) {\n              if (!auth.user || firstResult.user.objectId !== auth.user.id) {\n                throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token');\n              }\n            }\n            var cacheAdapter = config.cacheController;\n            cacheAdapter.user.del(firstResult.sessionToken);\n            inflatedObject = Parse.Object.fromJSON(firstResult);\n            // Notify LiveQuery server if possible\n            config.liveQueryController.onAfterDelete(inflatedObject.className, inflatedObject);\n            return triggers.maybeRunTrigger(triggers.Types.beforeDelete, auth, inflatedObject, null,  config);\n          }\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,\n            'Object not found for delete.');\n        });\n    }\n    return Promise.resolve({});\n  }).then(() => {\n    if (!auth.isMaster) {\n      return auth.getUserRoles();\n    } else {\n      return;\n    }\n  }).then(() => {\n    var options = {};\n    if (!auth.isMaster) {\n      options.acl = ['*'];\n      if (auth.user) {\n        options.acl.push(auth.user.id);\n        options.acl = options.acl.concat(auth.userRoles);\n      }\n    }\n\n    return config.database.destroy(className, {\n      objectId: objectId\n    }, options);\n  }).then(() => {\n    return triggers.maybeRunTrigger(triggers.Types.afterDelete, auth, inflatedObject, null, config);\n  }).catch((error) => {\n    handleSessionMissingError(error, className, auth);\n  });\n}\n\n// Returns a promise for a {response, status, location} object.\nfunction create(config, auth, className, restObject, clientSDK, options) {\n  enforceRoleSecurity('create', className, auth);\n  var write = new RestWrite(config, auth, className, null, restObject, null, clientSDK, options);\n  return write.execute();\n}\n\n// Returns a promise that contains the fields of the update that the\n// REST API is supposed to return.\n// Usually, this is just updatedAt.\nfunction update(config, auth, className, restWhere, restObject, clientSDK) {\n  enforceRoleSecurity('update', className, auth);\n\n  return Promise.resolve().then(() => {\n    const hasTriggers = checkTriggers(className, config, ['beforeSave', 'afterSave']);\n    const hasLiveQuery = checkLiveQuery(className, config);\n    if (hasTriggers || hasLiveQuery) {\n      // Do not use find, as it runs the before finds\n      return new RestQuery(config, auth, className, restWhere)\n        .forWrite()\n        .execute();\n    }\n    return Promise.resolve({});\n  }).then(({ results }) => {\n    var originalRestObject;\n    if (results && results.length) {\n      originalRestObject = results[0];\n    }\n    return new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK)\n      .execute();\n  }).catch((error) => {\n    handleSessionMissingError(error, className, auth);\n  });\n}\n\nfunction handleSessionMissingError(error, className) {\n  // If we're trying to update a user without / with bad session token\n  if (className === '_User'\n      && error.code === Parse.Error.OBJECT_NOT_FOUND) {\n    throw new Parse.Error(Parse.Error.SESSION_MISSING, 'Insufficient auth.');\n  }\n  throw error;\n}\n\nconst classesWithMasterOnlyAccess = ['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule'];\n// Disallowing access to the _Role collection except by master key\nfunction enforceRoleSecurity(method, className, auth) {\n  if (className === '_Installation' && !auth.isMaster) {\n    if (method === 'delete' || method === 'find') {\n      const error = `Clients aren't allowed to perform the ${method} operation on the installation collection.`\n      throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error);\n    }\n  }\n\n  //all volatileClasses are masterKey only\n  if(classesWithMasterOnlyAccess.indexOf(className) >= 0 && !auth.isMaster){\n    const error = `Clients aren't allowed to perform the ${method} operation on the ${className} collection.`\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error);\n  }\n\n  // readOnly masterKey is not allowed\n  if (auth.isReadOnly && (method === 'delete' || method === 'create' || method === 'update')) {\n    const error = `read-only masterKey isn't allowed to perform the ${method} operation.`\n    throw new Parse.Error(Parse.Error.OPERATION_FORBIDDEN, error);\n  }\n}\n\nmodule.exports = {\n  create,\n  del,\n  find,\n  get,\n  update\n};\n"]} \ No newline at end of file diff --git a/lib/triggers.js b/lib/triggers.js index 2c32e35ae2..8fc535ff07 100644 --- a/lib/triggers.js +++ b/lib/triggers.js @@ -252,6 +252,9 @@ function getResponseObject(request, resolve, reject) { }, error: function (code, message) { if (!message) { + if (code instanceof _node2.default.Error) { + return reject(code); + } message = code; code = _node2.default.Error.SCRIPT_FAILED; } @@ -468,4 +471,5 @@ function runLiveQueryEventHandlers(data, applicationId = _node2.default.applicat return; } _triggerStore[applicationId].LiveQuery.forEach(handler => handler(data)); -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/triggers.js"],"names":["addFunction","addJob","addTrigger","addLiveQueryEventHandler","removeFunction","removeTrigger","_unregisterAll","getTrigger","triggerExists","getFunction","getJob","getJobs","getValidator","getRequestObject","getRequestQueryObject","getResponseObject","maybeRunAfterFindTrigger","maybeRunQueryTrigger","maybeRunTrigger","inflate","runLiveQueryEventHandlers","Types","beforeSave","afterSave","beforeDelete","afterDelete","beforeFind","afterFind","baseStore","Validators","Functions","Jobs","LiveQuery","Triggers","Object","keys","reduce","base","key","freeze","validateClassNameForTriggers","className","type","restrictedClassNames","indexOf","_triggerStore","functionName","handler","validationHandler","applicationId","Parse","jobName","push","forEach","appId","triggerType","manager","undefined","auth","parseObject","originalParseObject","config","request","triggerName","object","master","log","loggerController","headers","ip","original","isMaster","user","installationId","query","count","isGet","resolve","reject","success","response","objects","map","toJSON","equals","_getSaveJSON","error","code","message","Error","SCRIPT_FAILED","scriptError","userIdForLog","id","logTriggerAfterHook","input","cleanInput","logger","truncateLogMessage","JSON","stringify","info","logTriggerSuccessBeforeHook","result","cleanResult","logTriggerErrorBeforeHook","Promise","trigger","fromJSON","triggerPromise","then","promiseResults","results","restWhere","restOptions","parseQuery","Query","_where","include","length","_include","split","skip","_skip","limit","_limit","requestObject","queryResult","jsonQuery","where","order","readPreference","includeReadPreference","subqueryReadPreference","err","javascriptKey","masterKey","data","restObject","copy"],"mappings":"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","file":"triggers.js","sourcesContent":["// triggers.js\nimport Parse    from 'parse/node';\nimport { logger } from './logger';\n\nexport const Types = {\n  beforeSave: 'beforeSave',\n  afterSave: 'afterSave',\n  beforeDelete: 'beforeDelete',\n  afterDelete: 'afterDelete',\n  beforeFind: 'beforeFind',\n  afterFind: 'afterFind'\n};\n\nconst baseStore = function() {\n  const Validators = {};\n  const Functions = {};\n  const Jobs = {};\n  const LiveQuery = [];\n  const Triggers = Object.keys(Types).reduce(function(base, key){\n    base[key] = {};\n    return base;\n  }, {});\n\n  return Object.freeze({\n    Functions,\n    Jobs,\n    Validators,\n    Triggers,\n    LiveQuery,\n  });\n};\n\nfunction validateClassNameForTriggers(className, type) {\n  const restrictedClassNames = [ '_Session' ];\n  if (restrictedClassNames.indexOf(className) != -1) {\n    throw `Triggers are not supported for ${className} class.`;\n  }\n  if (type == Types.beforeSave && className === '_PushStatus') {\n    // _PushStatus uses undocumented nested key increment ops\n    // allowing beforeSave would mess up the objects big time\n    // TODO: Allow proper documented way of using nested increment ops\n    throw 'Only afterSave is allowed on _PushStatus';\n  }\n  return className;\n}\n\nconst _triggerStore = {};\n\nexport function addFunction(functionName, handler, validationHandler, applicationId) {\n  applicationId = applicationId || Parse.applicationId;\n  _triggerStore[applicationId] =  _triggerStore[applicationId] || baseStore();\n  _triggerStore[applicationId].Functions[functionName] = handler;\n  _triggerStore[applicationId].Validators[functionName] = validationHandler;\n}\n\nexport function addJob(jobName, handler, applicationId) {\n  applicationId = applicationId || Parse.applicationId;\n  _triggerStore[applicationId] =  _triggerStore[applicationId] || baseStore();\n  _triggerStore[applicationId].Jobs[jobName] = handler;\n}\n\nexport function addTrigger(type, className, handler, applicationId) {\n  validateClassNameForTriggers(className, type);\n  applicationId = applicationId || Parse.applicationId;\n  _triggerStore[applicationId] =  _triggerStore[applicationId] || baseStore();\n  _triggerStore[applicationId].Triggers[type][className] = handler;\n}\n\nexport function addLiveQueryEventHandler(handler, applicationId) {\n  applicationId = applicationId || Parse.applicationId;\n  _triggerStore[applicationId] =  _triggerStore[applicationId] || baseStore();\n  _triggerStore[applicationId].LiveQuery.push(handler);\n}\n\nexport function removeFunction(functionName, applicationId) {\n  applicationId = applicationId || Parse.applicationId;\n  delete _triggerStore[applicationId].Functions[functionName]\n}\n\nexport function removeTrigger(type, className, applicationId) {\n  applicationId = applicationId || Parse.applicationId;\n  delete _triggerStore[applicationId].Triggers[type][className]\n}\n\nexport function _unregisterAll() {\n  Object.keys(_triggerStore).forEach(appId => delete _triggerStore[appId]);\n}\n\nexport function getTrigger(className, triggerType, applicationId) {\n  if (!applicationId) {\n    throw \"Missing ApplicationID\";\n  }\n  var manager = _triggerStore[applicationId]\n  if (manager\n    && manager.Triggers\n    && manager.Triggers[triggerType]\n    && manager.Triggers[triggerType][className]) {\n    return manager.Triggers[triggerType][className];\n  }\n  return undefined;\n}\n\nexport function triggerExists(className: string, type: string, applicationId: string): boolean {\n  return (getTrigger(className, type, applicationId) != undefined);\n}\n\nexport function getFunction(functionName, applicationId) {\n  var manager = _triggerStore[applicationId];\n  if (manager && manager.Functions) {\n    return manager.Functions[functionName];\n  }\n  return undefined;\n}\n\nexport function getJob(jobName, applicationId) {\n  var manager = _triggerStore[applicationId];\n  if (manager && manager.Jobs) {\n    return manager.Jobs[jobName];\n  }\n  return undefined;\n}\n\nexport function getJobs(applicationId) {\n  var manager = _triggerStore[applicationId];\n  if (manager && manager.Jobs) {\n    return manager.Jobs;\n  }\n  return undefined;\n}\n\n\nexport function getValidator(functionName, applicationId) {\n  var manager = _triggerStore[applicationId];\n  if (manager && manager.Validators) {\n    return manager.Validators[functionName];\n  }\n  return undefined;\n}\n\nexport function getRequestObject(triggerType, auth, parseObject, originalParseObject, config) {\n  var request = {\n    triggerName: triggerType,\n    object: parseObject,\n    master: false,\n    log: config.loggerController,\n    headers: config.headers,\n    ip: config.ip,\n  };\n\n  if (originalParseObject) {\n    request.original = originalParseObject;\n  }\n\n  if (!auth) {\n    return request;\n  }\n  if (auth.isMaster) {\n    request['master'] = true;\n  }\n  if (auth.user) {\n    request['user'] = auth.user;\n  }\n  if (auth.installationId) {\n    request['installationId'] = auth.installationId;\n  }\n  return request;\n}\n\nexport function getRequestQueryObject(triggerType, auth, query, count, config, isGet) {\n  isGet = !!isGet;\n\n  var request = {\n    triggerName: triggerType,\n    query,\n    master: false,\n    count,\n    log: config.loggerController,\n    isGet,\n    headers: config.headers,\n    ip: config.ip,\n  };\n\n  if (!auth) {\n    return request;\n  }\n  if (auth.isMaster) {\n    request['master'] = true;\n  }\n  if (auth.user) {\n    request['user'] = auth.user;\n  }\n  if (auth.installationId) {\n    request['installationId'] = auth.installationId;\n  }\n  return request;\n}\n\n// Creates the response object, and uses the request object to pass data\n// The API will call this with REST API formatted objects, this will\n// transform them to Parse.Object instances expected by Cloud Code.\n// Any changes made to the object in a beforeSave will be included.\nexport function getResponseObject(request, resolve, reject) {\n  return {\n    success: function(response) {\n      if (request.triggerName === Types.afterFind) {\n        if(!response){\n          response = request.objects;\n        }\n        response = response.map(object => {\n          return object.toJSON();\n        });\n        return resolve(response);\n      }\n      // Use the JSON response\n      if (response && !request.object.equals(response)\n          && request.triggerName === Types.beforeSave) {\n        return resolve(response);\n      }\n      response = {};\n      if (request.triggerName === Types.beforeSave) {\n        response['object'] = request.object._getSaveJSON();\n      }\n      return resolve(response);\n    },\n    error: function(code, message) {\n      if (!message) {\n        if (code instanceof Parse.Error) {\n          return reject(code)\n        }\n        message = code;\n        code = Parse.Error.SCRIPT_FAILED;\n      }\n      var scriptError = new Parse.Error(code, message);\n      return reject(scriptError);\n    }\n  }\n}\n\nfunction userIdForLog(auth) {\n  return (auth && auth.user) ? auth.user.id : undefined;\n}\n\nfunction logTriggerAfterHook(triggerType, className, input, auth) {\n  const cleanInput = logger.truncateLogMessage(JSON.stringify(input));\n  logger.info(`${triggerType} triggered for ${className} for user ${userIdForLog(auth)}:\\n  Input: ${cleanInput}`, {\n    className,\n    triggerType,\n    user: userIdForLog(auth)\n  });\n}\n\nfunction logTriggerSuccessBeforeHook(triggerType, className, input, result, auth) {\n  const cleanInput = logger.truncateLogMessage(JSON.stringify(input));\n  const cleanResult = logger.truncateLogMessage(JSON.stringify(result));\n  logger.info(`${triggerType} triggered for ${className} for user ${userIdForLog(auth)}:\\n  Input: ${cleanInput}\\n  Result: ${cleanResult}`, {\n    className,\n    triggerType,\n    user: userIdForLog(auth)\n  });\n}\n\nfunction logTriggerErrorBeforeHook(triggerType, className, input, auth, error) {\n  const cleanInput = logger.truncateLogMessage(JSON.stringify(input));\n  logger.error(`${triggerType} failed for ${className} for user ${userIdForLog(auth)}:\\n  Input: ${cleanInput}\\n  Error: ${JSON.stringify(error)}`, {\n    className,\n    triggerType,\n    error,\n    user: userIdForLog(auth)\n  });\n}\n\nexport function maybeRunAfterFindTrigger(triggerType, auth, className, objects, config) {\n  return new Promise((resolve, reject) => {\n    const trigger = getTrigger(className, triggerType, config.applicationId);\n    if (!trigger) {\n      return resolve();\n    }\n    const request = getRequestObject(triggerType, auth, null, null, config);\n    const response = getResponseObject(request,\n      object => {\n        resolve(object);\n      },\n      error => {\n        reject(error);\n      });\n    logTriggerSuccessBeforeHook(triggerType, className, 'AfterFind', JSON.stringify(objects), auth);\n    request.objects = objects.map(object => {\n      //setting the class name to transform into parse object\n      object.className = className;\n      return Parse.Object.fromJSON(object);\n    });\n    const triggerPromise = trigger(request, response);\n    if (triggerPromise && typeof triggerPromise.then === \"function\") {\n      return triggerPromise.then(promiseResults => {\n        if(promiseResults) {\n          resolve(promiseResults);\n        }else{\n          return reject(new Parse.Error(Parse.Error.SCRIPT_FAILED, \"AfterFind expect results to be returned in the promise\"));\n        }\n      });\n    }\n  }).then((results) => {\n    logTriggerAfterHook(triggerType, className, JSON.stringify(results), auth);\n    return results;\n  });\n}\n\nexport function maybeRunQueryTrigger(triggerType, className, restWhere, restOptions, config, auth, isGet) {\n  const trigger = getTrigger(className, triggerType, config.applicationId);\n  if (!trigger) {\n    return Promise.resolve({\n      restWhere,\n      restOptions\n    });\n  }\n\n  const parseQuery = new Parse.Query(className);\n  if (restWhere) {\n    parseQuery._where = restWhere;\n  }\n  let count = false;\n  if (restOptions) {\n    if (restOptions.include && restOptions.include.length > 0) {\n      parseQuery._include = restOptions.include.split(',');\n    }\n    if (restOptions.skip) {\n      parseQuery._skip = restOptions.skip;\n    }\n    if (restOptions.limit) {\n      parseQuery._limit = restOptions.limit;\n    }\n    count = !!restOptions.count;\n  }\n  const requestObject = getRequestQueryObject(triggerType, auth, parseQuery, count, config, isGet);\n  return Promise.resolve().then(() => {\n    return trigger(requestObject);\n  }).then((result) => {\n    let queryResult = parseQuery;\n    if (result && result instanceof Parse.Query) {\n      queryResult = result;\n    }\n    const jsonQuery = queryResult.toJSON();\n    if (jsonQuery.where) {\n      restWhere = jsonQuery.where;\n    }\n    if (jsonQuery.limit) {\n      restOptions = restOptions || {};\n      restOptions.limit = jsonQuery.limit;\n    }\n    if (jsonQuery.skip) {\n      restOptions = restOptions || {};\n      restOptions.skip = jsonQuery.skip;\n    }\n    if (jsonQuery.include) {\n      restOptions = restOptions || {};\n      restOptions.include = jsonQuery.include;\n    }\n    if (jsonQuery.keys) {\n      restOptions = restOptions || {};\n      restOptions.keys = jsonQuery.keys;\n    }\n    if (jsonQuery.order) {\n      restOptions = restOptions || {};\n      restOptions.order = jsonQuery.order;\n    }\n    if (requestObject.readPreference) {\n      restOptions = restOptions || {};\n      restOptions.readPreference = requestObject.readPreference;\n    }\n    if (requestObject.includeReadPreference) {\n      restOptions = restOptions || {};\n      restOptions.includeReadPreference = requestObject.includeReadPreference;\n    }\n    if (requestObject.subqueryReadPreference) {\n      restOptions = restOptions || {};\n      restOptions.subqueryReadPreference = requestObject.subqueryReadPreference;\n    }\n    return {\n      restWhere,\n      restOptions\n    };\n  }, (err) => {\n    if (typeof err === 'string') {\n      throw new Parse.Error(1, err);\n    } else {\n      throw err;\n    }\n  });\n}\n\n// To be used as part of the promise chain when saving/deleting an object\n// Will resolve successfully if no trigger is configured\n// Resolves to an object, empty or containing an object key. A beforeSave\n// trigger will set the object key to the rest format object to save.\n// originalParseObject is optional, we only need that for before/afterSave functions\nexport function maybeRunTrigger(triggerType, auth, parseObject, originalParseObject, config) {\n  if (!parseObject) {\n    return Promise.resolve({});\n  }\n  return new Promise(function (resolve, reject) {\n    var trigger = getTrigger(parseObject.className, triggerType, config.applicationId);\n    if (!trigger) return resolve();\n    var request = getRequestObject(triggerType, auth, parseObject, originalParseObject, config);\n    var response = getResponseObject(request, (object) => {\n      logTriggerSuccessBeforeHook(\n        triggerType, parseObject.className, parseObject.toJSON(), object, auth);\n      resolve(object);\n    }, (error) => {\n      logTriggerErrorBeforeHook(\n        triggerType, parseObject.className, parseObject.toJSON(), auth, error);\n      reject(error);\n    });\n    // Force the current Parse app before the trigger\n    Parse.applicationId = config.applicationId;\n    Parse.javascriptKey = config.javascriptKey || '';\n    Parse.masterKey = config.masterKey;\n\n    // AfterSave and afterDelete triggers can return a promise, which if they\n    // do, needs to be resolved before this promise is resolved,\n    // so trigger execution is synced with RestWrite.execute() call.\n    // If triggers do not return a promise, they can run async code parallel\n    // to the RestWrite.execute() call.\n    var triggerPromise = trigger(request, response);\n    if(triggerType === Types.afterSave || triggerType === Types.afterDelete)\n    {\n      logTriggerAfterHook(triggerType, parseObject.className, parseObject.toJSON(), auth);\n      if(triggerPromise && typeof triggerPromise.then === \"function\") {\n        return triggerPromise.then(resolve, resolve);\n      }\n      else {\n        return resolve();\n      }\n    }\n  });\n}\n\n// Converts a REST-format object to a Parse.Object\n// data is either className or an object\nexport function inflate(data, restObject) {\n  var copy = typeof data == 'object' ? data : {className: data};\n  for (var key in restObject) {\n    copy[key] = restObject[key];\n  }\n  return Parse.Object.fromJSON(copy);\n}\n\nexport function runLiveQueryEventHandlers(data, applicationId = Parse.applicationId) {\n  if (!_triggerStore || !_triggerStore[applicationId] || !_triggerStore[applicationId].LiveQuery) { return; }\n  _triggerStore[applicationId].LiveQuery.forEach((handler) => handler(data));\n}\n"]} \ No newline at end of file diff --git a/lib/vendor/mongodbUrl.js b/lib/vendor/mongodbUrl.js index 091ed8e742..2714315f99 100644 --- a/lib/vendor/mongodbUrl.js +++ b/lib/vendor/mongodbUrl.js @@ -921,4 +921,5 @@ function encodeAuth(str) { if (lastPos === 0) return str; if (lastPos < str.length) return out + str.slice(lastPos); return out; -} \ No newline at end of file +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/vendor/mongodbUrl.js"],"names":["punycode","require","exports","parse","urlParse","resolve","urlResolve","resolveObject","urlResolveObject","format","urlFormat","Url","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","path","href","protocolPattern","portPattern","simplePathPattern","hostnameMaxLen","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","url","parseQueryString","slashesDenoteHost","u","prototype","TypeError","hasHash","start","end","rest","lastPos","i","inWs","split","length","code","charCodeAt","isWs","slice","simplePath","exec","proto","lowerProto","toLowerCase","test","hostEnd","atSign","nonHost","decodeURIComponent","parseHost","ipv6Hostname","result","validateHostname","undefined","toASCII","p","h","autoEscapeStr","questionIdx","hashIdx","firstIdx","s","self","newRest","obj","call","encodeAuth","indexOf","stringify","newPathname","replace","source","relative","rel","tkeys","Object","keys","tk","tkey","rkeys","rk","rkey","v","k","relPath","shift","unshift","join","isSourceAbs","charAt","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","concat","authInHost","last","hasTrailingSlash","up","spliceOne","substr","push","isAbsolute","list","index","n","hexTable","Array","toString","toUpperCase","str","out","c","c2"],"mappings":"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","file":"mongodbUrl.js","sourcesContent":["// A slightly patched version of node's url module, with support for mongodb://\n// uris.\n//\n// See https://github.com/nodejs/node/blob/master/LICENSE for licensing\n// information\n\n'use strict';\n\nconst punycode = require('punycode');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nconst protocolPattern = /^([a-z0-9.+-]+:)/i;\nconst portPattern = /:[0-9]*$/;\n\n// Special case for a simple path URL\nconst simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/;\n\nconst hostnameMaxLen = 255;\n// protocols that can allow \"unsafe\" and \"unwise\" chars.\nconst unsafeProtocol = {\n  'javascript': true,\n  'javascript:': true\n};\n// protocols that never have a hostname.\nconst hostlessProtocol = {\n  'javascript': true,\n  'javascript:': true\n};\n// protocols that always contain a // bit.\nconst slashedProtocol = {\n  'http': true,\n  'http:': true,\n  'https': true,\n  'https:': true,\n  'ftp': true,\n  'ftp:': true,\n  'gopher': true,\n  'gopher:': true,\n  'file': true,\n  'file:': true\n};\nconst querystring = require('querystring');\n\n/* istanbul ignore next: improve coverage */\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url instanceof Url) return url;\n\n  var u = new Url();\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\n/* istanbul ignore next: improve coverage */\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (typeof url !== 'string') {\n    throw new TypeError('Parameter \"url\" must be a string, not ' + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var hasHash = false;\n  var start = -1;\n  var end = -1;\n  var rest = '';\n  var lastPos = 0;\n  var i = 0;\n  for (var inWs = false, split = false; i < url.length; ++i) {\n    const code = url.charCodeAt(i);\n\n    // Find first and last non-whitespace characters for trimming\n    const isWs = code === 32/* */ ||\n                 code === 9/*\\t*/ ||\n                 code === 13/*\\r*/ ||\n                 code === 10/*\\n*/ ||\n                 code === 12/*\\f*/ ||\n                 code === 160/*\\u00A0*/ ||\n                 code === 65279/*\\uFEFF*/;\n    if (start === -1) {\n      if (isWs)\n        continue;\n      lastPos = start = i;\n    } else {\n      if (inWs) {\n        if (!isWs) {\n          end = -1;\n          inWs = false;\n        }\n      } else if (isWs) {\n        end = i;\n        inWs = true;\n      }\n    }\n\n    // Only convert backslashes while we haven't seen a split character\n    if (!split) {\n      switch (code) {\n      case 35: // '#'\n        hasHash = true;\n        // Fall through\n      case 63: // '?'\n        split = true;\n        break;\n      case 92: // '\\\\'\n        if (i - lastPos > 0)\n          rest += url.slice(lastPos, i);\n        rest += '/';\n        lastPos = i + 1;\n        break;\n      }\n    } else if (!hasHash && code === 35/*#*/) {\n      hasHash = true;\n    }\n  }\n\n  // Check if string was non-empty (including strings with only whitespace)\n  if (start !== -1) {\n    if (lastPos === start) {\n      // We didn't convert any backslashes\n\n      if (end === -1) {\n        if (start === 0)\n          rest = url;\n        else\n          rest = url.slice(start);\n      } else {\n        rest = url.slice(start, end);\n      }\n    } else if (end === -1 && lastPos < url.length) {\n      // We converted some backslashes and have only part of the entire string\n      rest += url.slice(lastPos);\n    } else if (end !== -1 && lastPos < end) {\n      // We converted some backslashes and have only part of the entire string\n      rest += url.slice(lastPos, end);\n    }\n  }\n\n  if (!slashesDenoteHost && !hasHash) {\n    // Try fast path regexp\n    const simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.slice(1));\n        } else {\n          this.query = this.search.slice(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.slice(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || /^\\/\\/[^@\\/]+@[^@\\/]+/.test(rest)) {\n    var slashes = rest.charCodeAt(0) === 47/*/*/ &&\n                  rest.charCodeAt(1) === 47/*/*/;\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.slice(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:b path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    var hostEnd = -1;\n    var atSign = -1;\n    var nonHost = -1;\n    for (i = 0; i < rest.length; ++i) {\n      switch (rest.charCodeAt(i)) {\n      case 9:   // '\\t'\n      case 10:  // '\\n'\n      case 13:  // '\\r'\n      case 32:  // ' '\n      case 34:  // '\"'\n      case 37:  // '%'\n      case 39:  // '\\''\n      case 59:  // ';'\n      case 60:  // '<'\n      case 62:  // '>'\n      case 92:  // '\\\\'\n      case 94:  // '^'\n      case 96:  // '`'\n      case 123: // '{'\n      case 124: // '|'\n      case 125: // '}'\n        // Characters that are never ever allowed in a hostname from RFC 2396\n        if (nonHost === -1)\n          nonHost = i;\n        break;\n      case 35: // '#'\n      case 47: // '/'\n      case 63: // '?'\n        // Find the first instance of any host-ending characters\n        if (nonHost === -1)\n          nonHost = i;\n        hostEnd = i;\n        break;\n      case 64: // '@'\n        // At this point, either we have an explicit point where the\n        // auth portion cannot go past, or the last @ char is the decider.\n        atSign = i;\n        nonHost = -1;\n        break;\n      }\n      if (hostEnd !== -1)\n        break;\n    }\n    start = 0;\n    if (atSign !== -1) {\n      this.auth = decodeURIComponent(rest.slice(0, atSign));\n      start = atSign + 1;\n    }\n    if (nonHost === -1) {\n      this.host = rest.slice(start);\n      rest = '';\n    } else {\n      this.host = rest.slice(start, nonHost);\n      rest = rest.slice(nonHost);\n    }\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    if (typeof this.hostname !== 'string')\n      this.hostname = '';\n\n    var hostname = this.hostname;\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = hostname.charCodeAt(0) === 91/*[*/ &&\n                       hostname.charCodeAt(hostname.length - 1) === 93/*]*/;\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      const result = validateHostname(this, rest, hostname);\n      if (result !== undefined)\n        rest = result;\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.slice(1, -1);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    const result = autoEscapeStr(rest);\n    if (result !== undefined)\n      rest = result;\n  }\n\n  var questionIdx = -1;\n  var hashIdx = -1;\n  for (i = 0; i < rest.length; ++i) {\n    const code = rest.charCodeAt(i);\n    if (code === 35/*#*/) {\n      this.hash = rest.slice(i);\n      hashIdx = i;\n      break;\n    } else if (code === 63/*?*/ && questionIdx === -1) {\n      questionIdx = i;\n    }\n  }\n\n  if (questionIdx !== -1) {\n    if (hashIdx === -1) {\n      this.search = rest.slice(questionIdx);\n      this.query = rest.slice(questionIdx + 1);\n    } else {\n      this.search = rest.slice(questionIdx, hashIdx);\n      this.query = rest.slice(questionIdx + 1, hashIdx);\n    }\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n\n  var firstIdx = (questionIdx !== -1 &&\n                  (hashIdx === -1 || questionIdx < hashIdx)\n    ? questionIdx\n    : hashIdx);\n  if (firstIdx === -1) {\n    if (rest.length > 0)\n      this.pathname = rest;\n  } else if (firstIdx > 0) {\n    this.pathname = rest.slice(0, firstIdx);\n  }\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  // to support http.request\n  if (this.pathname || this.search) {\n    const p = this.pathname || '';\n    const s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n/* istanbul ignore next: improve coverage */\nfunction validateHostname(self, rest, hostname) {\n  for (var i = 0, lastPos; i <= hostname.length; ++i) {\n    var code;\n    if (i < hostname.length)\n      code = hostname.charCodeAt(i);\n    if (code === 46/*.*/ || i === hostname.length) {\n      if (i - lastPos > 0) {\n        if (i - lastPos > 63) {\n          self.hostname = hostname.slice(0, lastPos + 63);\n          return '/' + hostname.slice(lastPos + 63) + rest;\n        }\n      }\n      lastPos = i + 1;\n      continue;\n    } else if ((code >= 48/*0*/ && code <= 57/*9*/) ||\n               (code >= 97/*a*/ && code <= 122/*z*/) ||\n               code === 45/*-*/ ||\n               (code >= 65/*A*/ && code <= 90/*Z*/) ||\n               code === 43/*+*/ ||\n               code === 95/*_*/ ||\n               /* BEGIN MONGO URI PATCH */\n               code === 44/*,*/ ||\n               code === 58/*:*/ ||\n               /* END MONGO URI PATCH */\n               code > 127) {\n      continue;\n    }\n    // Invalid host character\n    self.hostname = hostname.slice(0, i);\n    if (i < hostname.length)\n      return '/' + hostname.slice(i) + rest;\n    break;\n  }\n}\n\n/* istanbul ignore next: improve coverage */\nfunction autoEscapeStr(rest) {\n  var newRest = '';\n  var lastPos = 0;\n  for (var i = 0; i < rest.length; ++i) {\n    // Automatically escape all delimiters and unwise characters from RFC 2396\n    // Also escape single quotes in case of an XSS attack\n    switch (rest.charCodeAt(i)) {\n    case 9:   // '\\t'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%09';\n      lastPos = i + 1;\n      break;\n    case 10:  // '\\n'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%0A';\n      lastPos = i + 1;\n      break;\n    case 13:  // '\\r'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%0D';\n      lastPos = i + 1;\n      break;\n    case 32:  // ' '\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%20';\n      lastPos = i + 1;\n      break;\n    case 34:  // '\"'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%22';\n      lastPos = i + 1;\n      break;\n    case 39:  // '\\''\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%27';\n      lastPos = i + 1;\n      break;\n    case 60:  // '<'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%3C';\n      lastPos = i + 1;\n      break;\n    case 62:  // '>'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%3E';\n      lastPos = i + 1;\n      break;\n    case 92:  // '\\\\'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%5C';\n      lastPos = i + 1;\n      break;\n    case 94:  // '^'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%5E';\n      lastPos = i + 1;\n      break;\n    case 96:  // '`'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%60';\n      lastPos = i + 1;\n      break;\n    case 123: // '{'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%7B';\n      lastPos = i + 1;\n      break;\n    case 124: // '|'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%7C';\n      lastPos = i + 1;\n      break;\n    case 125: // '}'\n      if (i - lastPos > 0)\n        newRest += rest.slice(lastPos, i);\n      newRest += '%7D';\n      lastPos = i + 1;\n      break;\n    }\n  }\n  if (lastPos === 0)\n    return;\n  if (lastPos < rest.length)\n    return newRest + rest.slice(lastPos);\n  else\n    return newRest;\n}\n\n// format a parsed object into a url string\n/* istanbul ignore next: improve coverage */\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (typeof obj === 'string') obj = urlParse(obj);\n\n  else if (typeof obj !== 'object' || obj === null)\n    throw new TypeError('Parameter \"urlObj\" must be an object, not ' +\n                        obj === null ? 'null' : typeof obj);\n\n  else if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n\n  return obj.format();\n}\n\n/* istanbul ignore next: improve coverage */\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeAuth(auth);\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '';\n  var pathname = this.pathname || '';\n  var hash = this.hash || '';\n  var host = false;\n  var query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n      this.hostname :\n      '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query !== null && typeof this.query === 'object')\n    query = querystring.stringify(this.query);\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.charCodeAt(protocol.length - 1) !== 58/*:*/)\n    protocol += ':';\n\n  var newPathname = '';\n  var lastPos = 0;\n  for (var i = 0; i < pathname.length; ++i) {\n    switch (pathname.charCodeAt(i)) {\n    case 35: // '#'\n      if (i - lastPos > 0)\n        newPathname += pathname.slice(lastPos, i);\n      newPathname += '%23';\n      lastPos = i + 1;\n      break;\n    case 63: // '?'\n      if (i - lastPos > 0)\n        newPathname += pathname.slice(lastPos, i);\n      newPathname += '%3F';\n      lastPos = i + 1;\n      break;\n    }\n  }\n  if (lastPos > 0) {\n    if (lastPos !== pathname.length)\n      pathname = newPathname + pathname.slice(lastPos);\n    else\n      pathname = newPathname;\n  }\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charCodeAt(0) !== 47/*/*/)\n      pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  search = search.replace('#', '%23');\n\n  if (hash && hash.charCodeAt(0) !== 35/*#*/) hash = '#' + hash;\n  if (search && search.charCodeAt(0) !== 63/*?*/) search = '?' + search;\n\n  return protocol + host + pathname + search + hash;\n};\n\n/* istanbul ignore next: improve coverage */\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\n/* istanbul ignore next: improve coverage */\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\n/* istanbul ignore next: improve coverage */\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\n/* istanbul ignore next: improve coverage */\nUrl.prototype.resolveObject = function(relative) {\n  if (typeof relative === 'string') {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host &&\n        !/^file:?$/.test(relative.protocol) &&\n        !hostlessProtocol[relative.protocol]) {\n      const relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/');\n  var isRelAbs = (\n    relative.host ||\n      relative.pathname && relative.pathname.charAt(0) === '/'\n  );\n  var mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname));\n  var removeAllDots = mustEndAbs;\n  var srcPath = result.pathname && result.pathname.split('/') || [];\n  var relPath = relative.pathname && relative.pathname.split('/') || [];\n  var psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n      relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (relative.search !== null && relative.search !== undefined) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occasionally the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      const authInHost = result.host && result.host.indexOf('@') > 0 ?\n        result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (result.pathname !== null || result.search !== null) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n    (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      spliceOne(srcPath, i);\n    } else if (last === '..') {\n      spliceOne(srcPath, i);\n      up++;\n    } else if (up) {\n      spliceOne(srcPath, i);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n      srcPath.length ? srcPath.shift() : '';\n    //occasionally the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    const authInHost = result.host && result.host.indexOf('@') > 0 ?\n      result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (result.pathname !== null || result.search !== null) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\n/* istanbul ignore next: improve coverage */\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.slice(1);\n    }\n    host = host.slice(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\n/* istanbul ignore next: improve coverage */\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n    list[i] = list[k];\n  list.pop();\n}\n\nvar hexTable = new Array(256);\nfor (var i = 0; i < 256; ++i)\n  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();\n/* istanbul ignore next: improve coverage */\nfunction encodeAuth(str) {\n  // faster encodeURIComponent alternative for encoding auth uri components\n  var out = '';\n  var lastPos = 0;\n  for (var i = 0; i < str.length; ++i) {\n    var c = str.charCodeAt(i);\n\n    // These characters do not need escaping:\n    // ! - . _ ~\n    // ' ( ) * :\n    // digits\n    // alpha (uppercase)\n    // alpha (lowercase)\n    if (c === 0x21 || c === 0x2D || c === 0x2E || c === 0x5F || c === 0x7E ||\n        (c >= 0x27 && c <= 0x2A) ||\n        (c >= 0x30 && c <= 0x3A) ||\n        (c >= 0x41 && c <= 0x5A) ||\n        (c >= 0x61 && c <= 0x7A)) {\n      continue;\n    }\n\n    if (i - lastPos > 0)\n      out += str.slice(lastPos, i);\n\n    lastPos = i + 1;\n\n    // Other ASCII characters\n    if (c < 0x80) {\n      out += hexTable[c];\n      continue;\n    }\n\n    // Multi-byte characters ...\n    if (c < 0x800) {\n      out += hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)];\n      continue;\n    }\n    if (c < 0xD800 || c >= 0xE000) {\n      out += hexTable[0xE0 | (c >> 12)] +\n             hexTable[0x80 | ((c >> 6) & 0x3F)] +\n             hexTable[0x80 | (c & 0x3F)];\n      continue;\n    }\n    // Surrogate pair\n    ++i;\n    var c2;\n    if (i < str.length)\n      c2 = str.charCodeAt(i) & 0x3FF;\n    else\n      c2 = 0;\n    c = 0x10000 + (((c & 0x3FF) << 10) | c2);\n    out += hexTable[0xF0 | (c >> 18)] +\n           hexTable[0x80 | ((c >> 12) & 0x3F)] +\n           hexTable[0x80 | ((c >> 6) & 0x3F)] +\n           hexTable[0x80 | (c & 0x3F)];\n  }\n  if (lastPos === 0)\n    return str;\n  if (lastPos < str.length)\n    return out + str.slice(lastPos);\n  return out;\n}\n"]} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000000..ca05b338ff --- /dev/null +++ b/package-lock.json @@ -0,0 +1,12280 @@ +{ + "name": "parse-server", + "version": "2.8.4", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "@babel/code-frame": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0-beta.44.tgz", + "integrity": "sha512-cuAuTTIQ9RqcFRJ/Y8PvTh+paepNcaGxwQwjIDRWPXmzzyAeCO4KqS9ikMvq0MCbRk6GlYKwfzStrcP3/jSL8g==", + "dev": true, + "requires": { + "@babel/highlight": "7.0.0-beta.44" + } + }, + "@babel/generator": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.0.0-beta.44.tgz", + "integrity": "sha512-5xVb7hlhjGcdkKpMXgicAVgx8syK5VJz193k0i/0sLP6DzE6lRrU1K3B/rFefgdo9LPGMAOOOAWW4jycj07ShQ==", + "dev": true, + "requires": { + "@babel/types": "7.0.0-beta.44", + "jsesc": "2.5.1", + "lodash": "4.17.5", + "source-map": "0.5.7", + "trim-right": "1.0.1" + }, + "dependencies": { + "jsesc": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.1.tgz", + "integrity": "sha1-5CGiqOINawgZ3yiQj3glJrlt0f4=", + "dev": true + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "@babel/helper-function-name": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.0.0-beta.44.tgz", + "integrity": "sha512-MHRG2qZMKMFaBavX0LWpfZ2e+hLloT++N7rfM3DYOMUOGCD8cVjqZpwiL8a0bOX3IYcQev1ruciT0gdFFRTxzg==", + "dev": true, + "requires": { + "@babel/helper-get-function-arity": "7.0.0-beta.44", + "@babel/template": "7.0.0-beta.44", + "@babel/types": "7.0.0-beta.44" + } + }, + "@babel/helper-get-function-arity": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0-beta.44.tgz", + "integrity": "sha512-w0YjWVwrM2HwP6/H3sEgrSQdkCaxppqFeJtAnB23pRiJB5E/O9Yp7JAAeWBl+gGEgmBFinnTyOv2RN7rcSmMiw==", + "dev": true, + "requires": { + "@babel/types": "7.0.0-beta.44" + } + }, + "@babel/helper-split-export-declaration": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0-beta.44.tgz", + "integrity": "sha512-aQ7QowtkgKKzPGf0j6u77kBMdUFVBKNHw2p/3HX/POt5/oz8ec5cs0GwlgM8Hz7ui5EwJnzyfRmkNF1Nx1N7aA==", + "dev": true, + "requires": { + "@babel/types": "7.0.0-beta.44" + } + }, + "@babel/highlight": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0-beta.44.tgz", + "integrity": "sha512-Il19yJvy7vMFm8AVAh6OZzaFoAd0hbkeMZiX3P5HGD+z7dyI7RzndHB0dg6Urh/VAFfHtpOIzDUSxmY6coyZWQ==", + "dev": true, + "requires": { + "chalk": "2.4.1", + "esutils": "2.0.2", + "js-tokens": "3.0.2" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "dev": true, + "requires": { + "has-flag": "3.0.0" + } + } + } + }, + "@babel/parser": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.0.0-beta.49.tgz", + "integrity": "sha1-lE0MW6KBK7FZ7b0iZ0Ov0mUXm9w=", + "dev": true + }, + "@babel/template": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.0.0-beta.44.tgz", + "integrity": "sha512-w750Sloq0UNifLx1rUqwfbnC6uSUk0mfwwgGRfdLiaUzfAOiH0tHJE6ILQIUi3KYkjiCDTskoIsnfqZvWLBDng==", + "dev": true, + "requires": { + "@babel/code-frame": "7.0.0-beta.44", + "@babel/types": "7.0.0-beta.44", + "babylon": "7.0.0-beta.44", + "lodash": "4.17.5" + }, + "dependencies": { + "babylon": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz", + "integrity": "sha512-5Hlm13BJVAioCHpImtFqNOF2H3ieTOHd0fmFGMxOJ9jgeFqeAwsv3u5P5cR7CSeFrkgHsT19DgFJkHV0/Mcd8g==", + "dev": true + } + } + }, + "@babel/traverse": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.0.0-beta.44.tgz", + "integrity": "sha512-UHuDz8ukQkJCDASKHf+oDt3FVUzFd+QYfuBIsiNu/4+/ix6pP/C+uQZJ6K1oEfbCMv/IKWbgDEh7fcsnIE5AtA==", + "dev": true, + "requires": { + "@babel/code-frame": "7.0.0-beta.44", + "@babel/generator": "7.0.0-beta.44", + "@babel/helper-function-name": "7.0.0-beta.44", + "@babel/helper-split-export-declaration": "7.0.0-beta.44", + "@babel/types": "7.0.0-beta.44", + "babylon": "7.0.0-beta.44", + "debug": "3.1.0", + "globals": "11.5.0", + "invariant": "2.2.4", + "lodash": "4.17.5" + }, + "dependencies": { + "babylon": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz", + "integrity": "sha512-5Hlm13BJVAioCHpImtFqNOF2H3ieTOHd0fmFGMxOJ9jgeFqeAwsv3u5P5cR7CSeFrkgHsT19DgFJkHV0/Mcd8g==", + "dev": true + }, + "globals": { + "version": "11.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.5.0.tgz", + "integrity": "sha512-hYyf+kI8dm3nORsiiXUQigOU62hDLfJ9G01uyGMxhc6BKsircrUhC4uJPQPUSuq2GrTmiiEt7ewxlMdBewfmKQ==", + "dev": true + } + } + }, + "@babel/types": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.0.0-beta.44.tgz", + "integrity": "sha512-5eTV4WRmqbaFM3v9gHAIljEQJU4Ssc6fxL61JN+Oe2ga/BwyjzjamwkCVVAQjHGuAX8i0BWo42dshL8eO5KfLQ==", + "dev": true, + "requires": { + "esutils": "2.0.2", + "lodash": "4.17.5", + "to-fast-properties": "2.0.0" + }, + "dependencies": { + "to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=", + "dev": true + } + } + }, + "@parse/fs-files-adapter": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@parse/fs-files-adapter/-/fs-files-adapter-1.0.1.tgz", + "integrity": "sha1-do94QIPo+Wc+9GPhmaG+X4N7QWU=" + }, + "@parse/node-gcm": { + "version": "0.14.12", + "resolved": "https://registry.npmjs.org/@parse/node-gcm/-/node-gcm-0.14.12.tgz", + "integrity": "sha512-fIXlY5LNR0VcPpFvwMvvczpByPNKxbCgMt/B3LwQqBjBCUJj/yEhBSePGUz2Kk+zOoj05v3KnG7ca+wZcAbh5A==", + "requires": { + "debug": "3.1.0", + "lodash": "4.17.5", + "request": "2.85.0" + } + }, + "@parse/push-adapter": { + "version": "3.0.0-alpha2", + "resolved": "https://registry.npmjs.org/@parse/push-adapter/-/push-adapter-3.0.0-alpha2.tgz", + "integrity": "sha1-a7LNC/XbpL/8vzQykDDHPaOJ3mI=", + "requires": { + "@parse/node-gcm": "0.14.12", + "apn": "3.0.0-alpha1", + "npmlog": "4.1.2", + "parse": "1.11.1" + } + }, + "@parse/s3-files-adapter": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@parse/s3-files-adapter/-/s3-files-adapter-1.2.1.tgz", + "integrity": "sha1-2dN8zoXj1CsogqX/J4m+wbF+xnU=", + "requires": { + "aws-sdk": "2.235.1" + } + }, + "@parse/simple-mailgun-adapter": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@parse/simple-mailgun-adapter/-/simple-mailgun-adapter-1.0.2.tgz", + "integrity": "sha1-uLW54Yg02MNtQ1KX7aZiTzoOnjU=", + "requires": { + "mailgun-js": "0.18.0" + } + }, + "@semantic-release/error": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-2.2.0.tgz", + "integrity": "sha512-9Tj/qn+y2j+sjCI3Jd+qseGtHjOAeg7dU2/lVcqIQ9TV3QDaDXDYXcoOHU+7o2Hwh8L8ymL4gfuO7KxDs3q2zg==", + "dev": true + }, + "@semantic-release/git": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@semantic-release/git/-/git-4.0.3.tgz", + "integrity": "sha512-XvW9mq4eegS5kQ4nNbgQjMC6AOO+9Oy6H+8iRTPCRkpJElhtecPUu/gqriZXEF/qqGXF891JKA3onCUjEwwWuQ==", + "dev": true, + "requires": { + "@semantic-release/error": "2.2.0", + "aggregate-error": "1.0.0", + "debug": "3.1.0", + "dir-glob": "2.0.0", + "execa": "0.10.0", + "fs-extra": "6.0.1", + "lodash": "4.17.5", + "micromatch": "3.1.10", + "p-reduce": "1.0.0" + }, + "dependencies": { + "arr-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", + "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", + "dev": true + }, + "array-unique": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", + "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "dev": true + }, + "braces": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "dev": true, + "requires": { + "arr-flatten": "1.1.0", + "array-unique": "0.3.2", + "extend-shallow": "2.0.1", + "fill-range": "4.0.0", + "isobject": "3.0.1", + "repeat-element": "1.1.2", + "snapdragon": "0.8.2", + "snapdragon-node": "2.1.1", + "split-string": "3.1.0", + "to-regex": "3.0.2" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "expand-brackets": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", + "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", + "dev": true, + "requires": { + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "posix-character-classes": "0.1.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + }, + "is-accessor-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", + "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "is-data-descriptor": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", + "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "is-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", + "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "0.1.6", + "is-data-descriptor": "0.1.4", + "kind-of": "5.1.0" + } + }, + "kind-of": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", + "dev": true + } + } + }, + "extglob": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", + "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", + "dev": true, + "requires": { + "array-unique": "0.3.2", + "define-property": "1.0.0", + "expand-brackets": "2.1.4", + "extend-shallow": "2.0.1", + "fragment-cache": "0.2.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "fill-range": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-number": "3.0.0", + "repeat-string": "1.6.1", + "to-regex-range": "2.1.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "fs-extra": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-6.0.1.tgz", + "integrity": "sha512-GnyIkKhhzXZUWFCaJzvyDLEEgDkPfb4/TPvJCJVuS8MWZgoSsErf++QpiAlDnKFcqhRlm+tIOcencCjyJE6ZCA==", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "jsonfile": "4.0.0", + "universalify": "0.1.2" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true + }, + "micromatch": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", + "dev": true, + "requires": { + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "braces": "2.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "extglob": "2.0.4", + "fragment-cache": "0.2.1", + "kind-of": "6.0.2", + "nanomatch": "1.2.9", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + } + } + } + }, + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", + "dev": true + }, + "accepts": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz", + "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=", + "requires": { + "mime-types": "2.1.18", + "negotiator": "0.6.1" + } + }, + "acorn": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.1.tgz", + "integrity": "sha512-d+nbxBUGKg7Arpsvbnlq61mc12ek3EY8EQldM3GPAhWJ1UVxC6TDGbIvUMNU6obBX3i1+ptCIzV4vq0gFPEGVQ==", + "dev": true + }, + "acorn-jsx": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-4.1.1.tgz", + "integrity": "sha512-JY+iV6r+cO21KtntVvFkD+iqjtdpRUpGqKWgfkCdZq1R+kbreEl8EcdcJR4SmiIgsIQT33s6QzheQ9a275Q8xw==", + "dev": true, + "requires": { + "acorn": "5.7.1" + } + }, + "adm-zip": { + "version": "0.4.7", + "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.7.tgz", + "integrity": "sha1-hgbCy/HEJs6MjsABdER/1Jtur8E=" + }, + "agent-base": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-4.2.0.tgz", + "integrity": "sha1-mDi1wzkrliutAx5qTF4QJKvsRc4=", + "requires": { + "es6-promisify": "5.0.0" + } + }, + "aggregate-error": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-1.0.0.tgz", + "integrity": "sha1-iINE2tAiCnLjr1CQYRf0h3GSX6w=", + "dev": true, + "requires": { + "clean-stack": "1.3.0", + "indent-string": "3.2.0" + } + }, + "ajv": { + "version": "5.5.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", + "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "requires": { + "co": "4.6.0", + "fast-deep-equal": "1.1.0", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1" + } + }, + "ajv-keywords": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.2.0.tgz", + "integrity": "sha1-6GuBnGAs+IIa1jdBNpjx3sAhhHo=", + "dev": true + }, + "ampersand-events": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ampersand-events/-/ampersand-events-2.0.2.tgz", + "integrity": "sha1-9AK8LhgwX6vZldvc07cFe73X00c=", + "dev": true, + "requires": { + "ampersand-version": "1.0.2", + "lodash": "4.17.5" + } + }, + "ampersand-state": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/ampersand-state/-/ampersand-state-5.0.3.tgz", + "integrity": "sha512-sr904K5zvw6mkGjFHhTcfBIdpoJ6mn/HrFg7OleRmBpw3apLb3Z0gVrgRTb7kK1wOLI34vs4S+IXqNHUeqWCzw==", + "dev": true, + "requires": { + "ampersand-events": "2.0.2", + "ampersand-version": "1.0.2", + "array-next": "0.0.1", + "key-tree-store": "1.3.0", + "lodash": "4.17.5" + } + }, + "ampersand-version": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/ampersand-version/-/ampersand-version-1.0.2.tgz", + "integrity": "sha1-/489TOrE0yzNg/a9Zpc5f3tZ4sA=", + "dev": true, + "requires": { + "find-root": "0.1.2", + "through2": "0.6.5" + } + }, + "ansi": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/ansi/-/ansi-0.3.1.tgz", + "integrity": "sha1-DELU+xcWDVqa8eSEus4cZpIsGyE=", + "dev": true + }, + "ansi-align": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-2.0.0.tgz", + "integrity": "sha1-w2rsy6VjuJzrVW82kPCx2eNUf38=", + "dev": true, + "requires": { + "string-width": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + } + } + }, + "ansi-escapes": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.1.0.tgz", + "integrity": "sha512-UgAb8H9D41AQnu/PbWlCofQVcnV4Gs2bBJi9eZPxfU/hgglFh3SMDMENRIqdr7H6XFnXdoknctFByVsCOotTVw==", + "dev": true + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=", + "dev": true + }, + "anymatch": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz", + "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==", + "dev": true, + "optional": true, + "requires": { + "micromatch": "2.3.11", + "normalize-path": "2.1.1" + } + }, + "apn": { + "version": "3.0.0-alpha1", + "resolved": "https://registry.npmjs.org/apn/-/apn-3.0.0-alpha1.tgz", + "integrity": "sha512-o/wVNAxaQ7eegLZ69rtNEgiIQFngPClOAFFsVowsBDjVIaFsRccI+kfTda6rmVuiMSiGBMurlX01jyMNlO+AXQ==", + "requires": { + "debug": "3.1.0", + "jsonwebtoken": "8.2.1", + "node-forge": "0.7.5", + "verror": "1.10.0" + } + }, + "append-field": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/append-field/-/append-field-0.1.0.tgz", + "integrity": "sha1-bdxY+gg8e8VF08WZWygwzCNm1Eo=" + }, + "aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==" + }, + "archiver": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/archiver/-/archiver-1.3.0.tgz", + "integrity": "sha1-TyGU1tj5nfP1MeaIHxTxXVX6ryI=", + "requires": { + "archiver-utils": "1.3.0", + "async": "2.6.0", + "buffer-crc32": "0.2.13", + "glob": "7.1.2", + "lodash": "4.17.5", + "readable-stream": "2.3.6", + "tar-stream": "1.6.1", + "walkdir": "0.0.11", + "zip-stream": "1.2.0" + } + }, + "archiver-utils": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-1.3.0.tgz", + "integrity": "sha1-5QtMCccL89aA4y/xt5lOn52JUXQ=", + "requires": { + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "lazystream": "1.0.0", + "lodash": "4.17.5", + "normalize-path": "2.1.1", + "readable-stream": "2.3.6" + } + }, + "are-we-there-yet": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.4.tgz", + "integrity": "sha1-u13KOCu5TwXhUZQ3PRb9O6HKEQ0=", + "requires": { + "delegates": "1.0.0", + "readable-stream": "2.3.6" + } + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "requires": { + "sprintf-js": "1.0.3" + } + }, + "arr-diff": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz", + "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=", + "dev": true, + "optional": true, + "requires": { + "arr-flatten": "1.1.0" + } + }, + "arr-flatten": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", + "dev": true + }, + "arr-union": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", + "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", + "dev": true + }, + "array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI=" + }, + "array-next": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/array-next/-/array-next-0.0.1.tgz", + "integrity": "sha1-5eRmCkwn/agVH/d2QnXQCQAGK+E=", + "dev": true + }, + "array-union": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz", + "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=", + "dev": true, + "requires": { + "array-uniq": "1.0.3" + } + }, + "array-uniq": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz", + "integrity": "sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=", + "dev": true + }, + "array-unique": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz", + "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=", + "dev": true, + "optional": true + }, + "arrify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", + "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=", + "dev": true + }, + "asn1": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz", + "integrity": "sha1-2sh4dxPJlmhJ/IGAd36+nB3fO4Y=" + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "assign-symbols": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", + "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", + "dev": true + }, + "ast-types": { + "version": "0.11.3", + "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.11.3.tgz", + "integrity": "sha1-wgdX/nLucSeOoP89h+XCyjDZ7fg=" + }, + "async": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.0.tgz", + "integrity": "sha512-xAfGg1/NTLBBKlHFmnd7PlmUW9KhVQIUuSrYem9xzFUZy13ScvtyGGejaae9iAVRiRq9+Cx7DPFaAAhCpyxyPw==", + "requires": { + "lodash": "4.17.5" + } + }, + "async-each": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz", + "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=", + "dev": true + }, + "async-limiter": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz", + "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg==" + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + }, + "atob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.1.tgz", + "integrity": "sha1-ri1acpR38onWDdf5amMUoi3Wwio=", + "dev": true + }, + "aws-sdk": { + "version": "2.235.1", + "resolved": "https://registry.npmjs.org/aws-sdk/-/aws-sdk-2.235.1.tgz", + "integrity": "sha1-uJXalIK7XZCy9UxFIDt6PBwrfOo=", + "requires": { + "buffer": "4.9.1", + "events": "1.1.1", + "ieee754": "1.1.8", + "jmespath": "0.15.0", + "querystring": "0.2.0", + "sax": "1.2.1", + "url": "0.10.3", + "uuid": "3.1.0", + "xml2js": "0.4.17", + "xmlbuilder": "4.2.1" + }, + "dependencies": { + "uuid": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.1.0.tgz", + "integrity": "sha1-PdPT55Crwk17DToDT/q6vijrvAQ=" + } + } + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" + }, + "aws4": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.7.0.tgz", + "integrity": "sha512-32NDda82rhwD9/JBCCkB+MRYDp0oSvlo2IL6rQWA10PQi7tDUM3eqMSltXmY+Oyl/7N3P3qNtAlv7X0d9bI28w==" + }, + "babel-cli": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-cli/-/babel-cli-6.26.0.tgz", + "integrity": "sha1-UCq1SHTX24itALiHoGODzgPQAvE=", + "dev": true, + "requires": { + "babel-core": "6.26.0", + "babel-polyfill": "6.26.0", + "babel-register": "6.26.0", + "babel-runtime": "6.26.0", + "chokidar": "1.7.0", + "commander": "2.16.0", + "convert-source-map": "1.5.1", + "fs-readdir-recursive": "1.1.0", + "glob": "7.1.2", + "lodash": "4.17.5", + "output-file-sync": "1.1.2", + "path-is-absolute": "1.0.1", + "slash": "1.0.0", + "source-map": "0.5.7", + "v8flags": "2.1.1" + }, + "dependencies": { + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "babel-code-frame": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", + "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "esutils": "2.0.2", + "js-tokens": "3.0.2" + } + }, + "babel-core": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-core/-/babel-core-6.26.0.tgz", + "integrity": "sha1-rzL3izGm/O8RnIew/Y2XU/A6C7g=", + "dev": true, + "requires": { + "babel-code-frame": "6.26.0", + "babel-generator": "6.26.1", + "babel-helpers": "6.24.1", + "babel-messages": "6.23.0", + "babel-register": "6.26.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "convert-source-map": "1.5.1", + "debug": "2.6.9", + "json5": "0.5.1", + "lodash": "4.17.5", + "minimatch": "3.0.4", + "path-is-absolute": "1.0.1", + "private": "0.1.8", + "slash": "1.0.0", + "source-map": "0.5.7" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "babel-eslint": { + "version": "8.2.3", + "resolved": "https://registry.npmjs.org/babel-eslint/-/babel-eslint-8.2.3.tgz", + "integrity": "sha512-0HeSTtaXg/Em7FCUWxwOT+KeFSO1O7LuRuzhk7g+1BjwdlQGlHq4OyMi3GqGxrNfEq8jEi6Hmt5ylEQUhurgiQ==", + "dev": true, + "requires": { + "@babel/code-frame": "7.0.0-beta.44", + "@babel/traverse": "7.0.0-beta.44", + "@babel/types": "7.0.0-beta.44", + "babylon": "7.0.0-beta.44", + "eslint-scope": "3.7.1", + "eslint-visitor-keys": "1.0.0" + }, + "dependencies": { + "babylon": { + "version": "7.0.0-beta.44", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz", + "integrity": "sha512-5Hlm13BJVAioCHpImtFqNOF2H3ieTOHd0fmFGMxOJ9jgeFqeAwsv3u5P5cR7CSeFrkgHsT19DgFJkHV0/Mcd8g==", + "dev": true + } + } + }, + "babel-generator": { + "version": "6.26.1", + "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz", + "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==", + "dev": true, + "requires": { + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "detect-indent": "4.0.0", + "jsesc": "1.3.0", + "lodash": "4.17.5", + "source-map": "0.5.7", + "trim-right": "1.0.1" + }, + "dependencies": { + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "babel-helper-builder-binary-assignment-operator-visitor": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.24.1.tgz", + "integrity": "sha1-zORReto1b0IgvK6KAsKzRvmlZmQ=", + "dev": true, + "requires": { + "babel-helper-explode-assignable-expression": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-call-delegate": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz", + "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=", + "dev": true, + "requires": { + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-define-map": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz", + "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=", + "dev": true, + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.5" + } + }, + "babel-helper-explode-assignable-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.24.1.tgz", + "integrity": "sha1-8luCz33BBDPFX3BZLVdGQArCLKo=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz", + "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=", + "dev": true, + "requires": { + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-get-function-arity": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz", + "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-hoist-variables": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz", + "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-optimise-call-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz", + "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-regex": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz", + "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.5" + } + }, + "babel-helper-remap-async-to-generator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.24.1.tgz", + "integrity": "sha1-XsWBgnrXI/7N04HxySg5BnbkVRs=", + "dev": true, + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-replace-supers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz", + "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=", + "dev": true, + "requires": { + "babel-helper-optimise-call-expression": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helpers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz", + "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-messages": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", + "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-check-es2015-constants": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz", + "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-syntax-async-functions": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz", + "integrity": "sha1-ytnK0RkbWtY0vzCuCHI5HgZHvpU=", + "dev": true + }, + "babel-plugin-syntax-exponentiation-operator": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz", + "integrity": "sha1-nufoM3KQ2pUoggGmpX9BcDF4MN4=", + "dev": true + }, + "babel-plugin-syntax-flow": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz", + "integrity": "sha1-TDqyCiryaqIM0lmVw5jE63AxDI0=", + "dev": true + }, + "babel-plugin-syntax-object-rest-spread": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz", + "integrity": "sha1-/WU28rzhODb/o6VFjEkDpZe7O/U=", + "dev": true + }, + "babel-plugin-syntax-trailing-function-commas": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz", + "integrity": "sha1-ugNgk3+NBuQBgKQ/4NVhb/9TLPM=", + "dev": true + }, + "babel-plugin-transform-async-to-generator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.24.1.tgz", + "integrity": "sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E=", + "dev": true, + "requires": { + "babel-helper-remap-async-to-generator": "6.24.1", + "babel-plugin-syntax-async-functions": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-arrow-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz", + "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-block-scoped-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz", + "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-block-scoping": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz", + "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.5" + } + }, + "babel-plugin-transform-es2015-classes": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", + "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", + "dev": true, + "requires": { + "babel-helper-define-map": "6.26.0", + "babel-helper-function-name": "6.24.1", + "babel-helper-optimise-call-expression": "6.24.1", + "babel-helper-replace-supers": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-computed-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz", + "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-destructuring": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz", + "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-duplicate-keys": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz", + "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-for-of": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz", + "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz", + "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=", + "dev": true, + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz", + "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-amd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz", + "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=", + "dev": true, + "requires": { + "babel-plugin-transform-es2015-modules-commonjs": "6.26.2", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-commonjs": { + "version": "6.26.2", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz", + "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==", + "dev": true, + "requires": { + "babel-plugin-transform-strict-mode": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-systemjs": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz", + "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=", + "dev": true, + "requires": { + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-umd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz", + "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=", + "dev": true, + "requires": { + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-object-super": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz", + "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=", + "dev": true, + "requires": { + "babel-helper-replace-supers": "6.24.1", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-parameters": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz", + "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=", + "dev": true, + "requires": { + "babel-helper-call-delegate": "6.24.1", + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-shorthand-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz", + "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-spread": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz", + "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-sticky-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz", + "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=", + "dev": true, + "requires": { + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-template-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz", + "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-typeof-symbol": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz", + "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-unicode-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz", + "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=", + "dev": true, + "requires": { + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "regexpu-core": "2.0.0" + } + }, + "babel-plugin-transform-exponentiation-operator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.24.1.tgz", + "integrity": "sha1-KrDJx/MJj6SJB3cruBP+QejeOg4=", + "dev": true, + "requires": { + "babel-helper-builder-binary-assignment-operator-visitor": "6.24.1", + "babel-plugin-syntax-exponentiation-operator": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-flow-strip-types": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz", + "integrity": "sha1-hMtnKTXUNxT9wyvOhFaNh0Qc988=", + "dev": true, + "requires": { + "babel-plugin-syntax-flow": "6.18.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-object-rest-spread": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-object-rest-spread/-/babel-plugin-transform-object-rest-spread-6.26.0.tgz", + "integrity": "sha1-DzZpLVD+9rfi1LOsFHgTepY7ewY=", + "dev": true, + "requires": { + "babel-plugin-syntax-object-rest-spread": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-regenerator": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz", + "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=", + "dev": true, + "requires": { + "regenerator-transform": "0.10.1" + } + }, + "babel-plugin-transform-strict-mode": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz", + "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-polyfill": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-polyfill/-/babel-polyfill-6.26.0.tgz", + "integrity": "sha1-N5k3q8Z9eJWXCtxiHyhM2WbPIVM=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "core-js": "2.5.6", + "regenerator-runtime": "0.10.5" + }, + "dependencies": { + "regenerator-runtime": { + "version": "0.10.5", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz", + "integrity": "sha1-M2w+/BIgrc7dosn6tntaeVWjNlg=", + "dev": true + } + } + }, + "babel-preset-env": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/babel-preset-env/-/babel-preset-env-1.6.1.tgz", + "integrity": "sha512-W6VIyA6Ch9ePMI7VptNn2wBM6dbG0eSz25HEiL40nQXCsXGTGZSTZu1Iap+cj3Q0S5a7T9+529l/5Bkvd+afNA==", + "dev": true, + "requires": { + "babel-plugin-check-es2015-constants": "6.22.0", + "babel-plugin-syntax-trailing-function-commas": "6.22.0", + "babel-plugin-transform-async-to-generator": "6.24.1", + "babel-plugin-transform-es2015-arrow-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoped-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoping": "6.26.0", + "babel-plugin-transform-es2015-classes": "6.24.1", + "babel-plugin-transform-es2015-computed-properties": "6.24.1", + "babel-plugin-transform-es2015-destructuring": "6.23.0", + "babel-plugin-transform-es2015-duplicate-keys": "6.24.1", + "babel-plugin-transform-es2015-for-of": "6.23.0", + "babel-plugin-transform-es2015-function-name": "6.24.1", + "babel-plugin-transform-es2015-literals": "6.22.0", + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-plugin-transform-es2015-modules-commonjs": "6.26.2", + "babel-plugin-transform-es2015-modules-systemjs": "6.24.1", + "babel-plugin-transform-es2015-modules-umd": "6.24.1", + "babel-plugin-transform-es2015-object-super": "6.24.1", + "babel-plugin-transform-es2015-parameters": "6.24.1", + "babel-plugin-transform-es2015-shorthand-properties": "6.24.1", + "babel-plugin-transform-es2015-spread": "6.22.0", + "babel-plugin-transform-es2015-sticky-regex": "6.24.1", + "babel-plugin-transform-es2015-template-literals": "6.22.0", + "babel-plugin-transform-es2015-typeof-symbol": "6.23.0", + "babel-plugin-transform-es2015-unicode-regex": "6.24.1", + "babel-plugin-transform-exponentiation-operator": "6.24.1", + "babel-plugin-transform-regenerator": "6.26.0", + "browserslist": "2.11.3", + "invariant": "2.2.4", + "semver": "5.5.0" + } + }, + "babel-register": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz", + "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=", + "dev": true, + "requires": { + "babel-core": "6.26.0", + "babel-runtime": "6.26.0", + "core-js": "2.5.6", + "home-or-tmp": "2.0.0", + "lodash": "4.17.5", + "mkdirp": "0.5.1", + "source-map-support": "0.4.18" + } + }, + "babel-runtime": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", + "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", + "requires": { + "core-js": "2.5.6", + "regenerator-runtime": "0.11.1" + } + }, + "babel-template": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", + "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "lodash": "4.17.5" + } + }, + "babel-traverse": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", + "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=", + "dev": true, + "requires": { + "babel-code-frame": "6.26.0", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "debug": "2.6.9", + "globals": "9.18.0", + "invariant": "2.2.4", + "lodash": "4.17.5" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + } + } + }, + "babel-types": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", + "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "esutils": "2.0.2", + "lodash": "4.17.5", + "to-fast-properties": "1.0.3" + } + }, + "babylon": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz", + "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==", + "dev": true + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "base": { + "version": "0.11.2", + "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", + "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", + "dev": true, + "requires": { + "cache-base": "1.0.1", + "class-utils": "0.3.6", + "component-emitter": "1.2.1", + "define-property": "1.0.0", + "isobject": "3.0.1", + "mixin-deep": "1.3.1", + "pascalcase": "0.1.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true + } + } + }, + "base64-js": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz", + "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==" + }, + "bcrypt": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-3.0.0.tgz", + "integrity": "sha512-gjicxsD4e5U3nH0EqiEb5y+fKpsZ7F52wcnmNfu45nxnolWVAYh7NgbdfilY+5x1v6cLspxmzz4hf+ju2pFxhA==", + "optional": true, + "requires": { + "nan": "2.10.0", + "node-pre-gyp": "0.10.2" + }, + "dependencies": { + "abbrev": { + "version": "1.1.1", + "bundled": true, + "optional": true + }, + "ansi-regex": { + "version": "2.1.1", + "bundled": true + }, + "aproba": { + "version": "1.2.0", + "bundled": true, + "optional": true + }, + "are-we-there-yet": { + "version": "1.1.5", + "bundled": true, + "optional": true, + "requires": { + "delegates": "1.0.0", + "readable-stream": "2.3.5" + } + }, + "balanced-match": { + "version": "1.0.0", + "bundled": true + }, + "brace-expansion": { + "version": "1.1.11", + "bundled": true, + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "chownr": { + "version": "1.0.1", + "bundled": true, + "optional": true + }, + "code-point-at": { + "version": "1.1.0", + "bundled": true + }, + "concat-map": { + "version": "0.0.1", + "bundled": true + }, + "console-control-strings": { + "version": "1.1.0", + "bundled": true + }, + "core-util-is": { + "version": "1.0.2", + "bundled": true, + "optional": true + }, + "debug": { + "version": "2.6.9", + "bundled": true, + "optional": true, + "requires": { + "ms": "2.0.0" + } + }, + "deep-extend": { + "version": "0.6.0", + "bundled": true, + "optional": true + }, + "delegates": { + "version": "1.0.0", + "bundled": true, + "optional": true + }, + "detect-libc": { + "version": "1.0.3", + "bundled": true, + "optional": true + }, + "fs-minipass": { + "version": "1.2.5", + "bundled": true, + "optional": true, + "requires": { + "minipass": "2.3.3" + } + }, + "fs.realpath": { + "version": "1.0.0", + "bundled": true, + "optional": true + }, + "gauge": { + "version": "2.7.4", + "bundled": true, + "optional": true, + "requires": { + "aproba": "1.2.0", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.3" + } + }, + "glob": { + "version": "7.1.2", + "bundled": true, + "optional": true, + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "has-unicode": { + "version": "2.0.1", + "bundled": true, + "optional": true + }, + "iconv-lite": { + "version": "0.4.23", + "bundled": true, + "optional": true, + "requires": { + "safer-buffer": "2.1.2" + } + }, + "ignore-walk": { + "version": "3.0.1", + "bundled": true, + "optional": true, + "requires": { + "minimatch": "3.0.4" + } + }, + "inflight": { + "version": "1.0.6", + "bundled": true, + "optional": true, + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "bundled": true + }, + "ini": { + "version": "1.3.5", + "bundled": true, + "optional": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "bundled": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "isarray": { + "version": "1.0.0", + "bundled": true, + "optional": true + }, + "minimatch": { + "version": "3.0.4", + "bundled": true, + "requires": { + "brace-expansion": "1.1.11" + } + }, + "minimist": { + "version": "0.0.8", + "bundled": true + }, + "minipass": { + "version": "2.3.3", + "bundled": true, + "requires": { + "safe-buffer": "5.1.2", + "yallist": "3.0.2" + }, + "dependencies": { + "safe-buffer": { + "version": "5.1.2", + "bundled": true + }, + "yallist": { + "version": "3.0.2", + "bundled": true + } + } + }, + "minizlib": { + "version": "1.1.0", + "bundled": true, + "optional": true, + "requires": { + "minipass": "2.3.3" + } + }, + "mkdirp": { + "version": "0.5.1", + "bundled": true, + "requires": { + "minimist": "0.0.8" + } + }, + "ms": { + "version": "2.0.0", + "bundled": true, + "optional": true + }, + "needle": { + "version": "2.2.1", + "bundled": true, + "optional": true, + "requires": { + "debug": "2.6.9", + "iconv-lite": "0.4.23", + "sax": "1.2.4" + } + }, + "node-pre-gyp": { + "version": "0.10.2", + "bundled": true, + "optional": true, + "requires": { + "detect-libc": "1.0.3", + "mkdirp": "0.5.1", + "needle": "2.2.1", + "nopt": "4.0.1", + "npm-packlist": "1.1.10", + "npmlog": "4.1.2", + "rc": "1.2.8", + "rimraf": "2.6.2", + "semver": "5.5.0", + "tar": "4.4.4" + } + }, + "nopt": { + "version": "4.0.1", + "bundled": true, + "optional": true, + "requires": { + "abbrev": "1.1.1", + "osenv": "0.1.5" + } + }, + "npm-bundled": { + "version": "1.0.3", + "bundled": true, + "optional": true + }, + "npm-packlist": { + "version": "1.1.10", + "bundled": true, + "optional": true, + "requires": { + "ignore-walk": "3.0.1", + "npm-bundled": "1.0.3" + } + }, + "npmlog": { + "version": "4.1.2", + "bundled": true, + "optional": true, + "requires": { + "are-we-there-yet": "1.1.5", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.0" + } + }, + "number-is-nan": { + "version": "1.0.1", + "bundled": true + }, + "object-assign": { + "version": "4.1.1", + "bundled": true, + "optional": true + }, + "once": { + "version": "1.4.0", + "bundled": true, + "requires": { + "wrappy": "1.0.2" + } + }, + "os-homedir": { + "version": "1.0.2", + "bundled": true, + "optional": true + }, + "os-tmpdir": { + "version": "1.0.2", + "bundled": true, + "optional": true + }, + "osenv": { + "version": "0.1.5", + "bundled": true, + "optional": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "bundled": true, + "optional": true + }, + "process-nextick-args": { + "version": "2.0.0", + "bundled": true, + "optional": true + }, + "rc": { + "version": "1.2.8", + "bundled": true, + "optional": true, + "requires": { + "deep-extend": "0.6.0", + "ini": "1.3.5", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "bundled": true, + "optional": true + } + } + }, + "readable-stream": { + "version": "2.3.5", + "bundled": true, + "optional": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "rimraf": { + "version": "2.6.2", + "bundled": true, + "optional": true, + "requires": { + "glob": "7.1.2" + } + }, + "safe-buffer": { + "version": "5.1.1", + "bundled": true + }, + "safer-buffer": { + "version": "2.1.2", + "bundled": true, + "optional": true + }, + "sax": { + "version": "1.2.4", + "bundled": true, + "optional": true + }, + "semver": { + "version": "5.5.0", + "bundled": true, + "optional": true + }, + "set-blocking": { + "version": "2.0.0", + "bundled": true, + "optional": true + }, + "signal-exit": { + "version": "3.0.2", + "bundled": true, + "optional": true + }, + "string-width": { + "version": "1.0.2", + "bundled": true, + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "string_decoder": { + "version": "1.0.3", + "bundled": true, + "optional": true, + "requires": { + "safe-buffer": "5.1.1" + } + }, + "strip-ansi": { + "version": "3.0.1", + "bundled": true, + "requires": { + "ansi-regex": "2.1.1" + } + }, + "strip-json-comments": { + "version": "2.0.1", + "bundled": true, + "optional": true + }, + "tar": { + "version": "4.4.4", + "bundled": true, + "optional": true, + "requires": { + "chownr": "1.0.1", + "fs-minipass": "1.2.5", + "minipass": "2.3.3", + "minizlib": "1.1.0", + "mkdirp": "0.5.1", + "safe-buffer": "5.1.2", + "yallist": "3.0.2" + }, + "dependencies": { + "safe-buffer": { + "version": "5.1.2", + "bundled": true, + "optional": true + }, + "yallist": { + "version": "3.0.2", + "bundled": true, + "optional": true + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "bundled": true, + "optional": true + }, + "wide-align": { + "version": "1.1.3", + "bundled": true, + "optional": true, + "requires": { + "string-width": "1.0.2" + } + }, + "wrappy": { + "version": "1.0.2", + "bundled": true + } + } + }, + "bcrypt-nodejs": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/bcrypt-nodejs/-/bcrypt-nodejs-0.0.3.tgz", + "integrity": "sha1-xgkX8m3CNWYVZsaBBhwwPCsohCs=", + "dev": true + }, + "bcrypt-pbkdf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz", + "integrity": "sha1-Y7xdy2EzG5K8Bf1SiVPDNGKgb40=", + "optional": true, + "requires": { + "tweetnacl": "0.14.5" + } + }, + "bcryptjs": { + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/bcryptjs/-/bcryptjs-2.4.3.tgz", + "integrity": "sha1-mrVie5PmBiH/fNrF2pczAn3x0Ms=" + }, + "binary-extensions": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.11.0.tgz", + "integrity": "sha1-RqoXUftqL5PuXmibsQh9SxTGwgU=", + "dev": true + }, + "bl": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/bl/-/bl-1.2.2.tgz", + "integrity": "sha512-e8tQYnZodmebYDWGH7KMRvtzKXaJHx3BbilrgZCfvyLUYdKpK1t5PSPmpkny/SgiTSCnjfLW7v5rlONXVFkQEA==", + "requires": { + "readable-stream": "2.3.6", + "safe-buffer": "5.1.2" + } + }, + "bluebird": { + "version": "3.5.1", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.1.tgz", + "integrity": "sha512-MKiLiV+I1AA596t9w1sQJ8jkiSr5+ZKi0WKrYGUn6d1Fx+Ij4tIj+m2WMQSGczs5jZVxV339chE8iwk6F64wjA==", + "dev": true + }, + "body-parser": { + "version": "1.18.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.3.tgz", + "integrity": "sha1-WykhmP/dVTs6DyDe0FkrlWlVyLQ=", + "requires": { + "bytes": "3.0.0", + "content-type": "1.0.4", + "debug": "2.6.9", + "depd": "1.1.2", + "http-errors": "1.6.3", + "iconv-lite": "0.4.23", + "on-finished": "2.3.0", + "qs": "6.5.2", + "raw-body": "2.3.3", + "type-is": "1.6.16" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha1-XRKFFd8TT/Mn6QpMk/Tgd6U2NB8=", + "requires": { + "ms": "2.0.0" + } + } + } + }, + "boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha1-aN/1++YMUes3cl6p4+0xDcwed24=", + "dev": true + }, + "boom": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/boom/-/boom-4.3.1.tgz", + "integrity": "sha1-T4owBctKfjiJ90kDD9JbluAdLjE=", + "requires": { + "hoek": "4.2.1" + } + }, + "boxen": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/boxen/-/boxen-1.3.0.tgz", + "integrity": "sha512-TNPjfTr432qx7yOjQyaXm3dSR0MH9vXp7eT1BFSl/C51g+EFnOR9hTg1IreahGBmDNCehscshe45f+C1TBZbLw==", + "dev": true, + "requires": { + "ansi-align": "2.0.0", + "camelcase": "4.1.0", + "chalk": "2.4.1", + "cli-boxes": "1.0.0", + "string-width": "2.1.1", + "term-size": "1.2.0", + "widest-line": "2.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + } + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz", + "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=", + "dev": true, + "optional": true, + "requires": { + "expand-range": "1.8.2", + "preserve": "0.2.0", + "repeat-element": "1.1.2" + } + }, + "browserslist": { + "version": "2.11.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-2.11.3.tgz", + "integrity": "sha512-yWu5cXT7Av6mVwzWc8lMsJMHWn4xyjSuGYi4IozbVTLUOEYPSagUB8kiMDUHA1fS3zjr8nkxkn9jdvug4BBRmA==", + "dev": true, + "requires": { + "caniuse-lite": "1.0.30000836", + "electron-to-chromium": "1.3.45" + } + }, + "bson": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/bson/-/bson-1.0.6.tgz", + "integrity": "sha512-D8zmlb46xfuK2gGvKmUjIklQEouN2nQ0LEHHeZ/NoHM2LDiMk2EYzZ5Ntw/Urk+bgMDosOZxaRzXxvhI5TcAVQ==" + }, + "buffer": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "requires": { + "base64-js": "1.3.0", + "ieee754": "1.1.8", + "isarray": "1.0.0" + } + }, + "buffer-alloc": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz", + "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==", + "requires": { + "buffer-alloc-unsafe": "1.1.0", + "buffer-fill": "1.0.0" + } + }, + "buffer-alloc-unsafe": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz", + "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==" + }, + "buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=" + }, + "buffer-equal-constant-time": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz", + "integrity": "sha1-+OcRMvf/5uAaXJaXpMbz5I1cyBk=" + }, + "buffer-fill": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz", + "integrity": "sha1-+PeLdniYiO858gXNY39o5wISKyw=" + }, + "buffer-from": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", + "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==" + }, + "buffer-shims": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/buffer-shims/-/buffer-shims-1.0.0.tgz", + "integrity": "sha1-mXjOMXOIxkmth5MCjDR37wRKi1E=", + "dev": true + }, + "buffer-writer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/buffer-writer/-/buffer-writer-1.0.1.tgz", + "integrity": "sha1-Iqk2kB4wKa/NdUfrRIfOtpejvwg=" + }, + "busboy": { + "version": "0.2.14", + "resolved": "https://registry.npmjs.org/busboy/-/busboy-0.2.14.tgz", + "integrity": "sha1-bCpiLvz0fFe7vh4qnDetNseSVFM=", + "requires": { + "dicer": "0.2.5", + "readable-stream": "1.1.14" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "bytes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz", + "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=" + }, + "cache-base": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", + "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", + "dev": true, + "requires": { + "collection-visit": "1.0.0", + "component-emitter": "1.2.1", + "get-value": "2.0.6", + "has-value": "1.0.0", + "isobject": "3.0.1", + "set-value": "2.0.0", + "to-object-path": "0.3.0", + "union-value": "1.0.0", + "unset-value": "1.0.0" + }, + "dependencies": { + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "caller-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz", + "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", + "dev": true, + "requires": { + "callsites": "0.2.0" + } + }, + "callsites": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz", + "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", + "dev": true + }, + "camelcase": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", + "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=", + "dev": true + }, + "caniuse-lite": { + "version": "1.0.30000836", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30000836.tgz", + "integrity": "sha512-DlVR8sVTKDgd7t95U0shX3g7MeJ/DOjKOhUcaiXqnVmnO5sG4Tn2rLVOkVfPUJgnQNxnGe8/4GK0dGSI+AagQw==", + "dev": true + }, + "capture-stack-trace": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/capture-stack-trace/-/capture-stack-trace-1.0.0.tgz", + "integrity": "sha1-Sm+gc5nCa7pH8LJJa00PtAjFVQ0=", + "dev": true + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "caw": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/caw/-/caw-2.0.1.tgz", + "integrity": "sha512-Cg8/ZSBEa8ZVY9HspcGUYaK63d/bN7rqS3CYCzEGUxuYv6UlmcjzDUz2fCFFHyTvUW5Pk0I+3hkA3iXlIj6guA==", + "dev": true, + "requires": { + "get-proxy": "2.1.0", + "isurl": "1.0.0", + "tunnel-agent": "0.6.0", + "url-to-options": "1.0.1" + } + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + }, + "dependencies": { + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=", + "dev": true + } + } + }, + "chardet": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz", + "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=", + "dev": true + }, + "cheerio": { + "version": "0.22.0", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.22.0.tgz", + "integrity": "sha1-qbqoYKP5tZWmuBsahocxIe06Jp4=", + "dev": true, + "requires": { + "css-select": "1.2.0", + "dom-serializer": "0.1.0", + "entities": "1.1.1", + "htmlparser2": "3.9.2", + "lodash.assignin": "4.2.0", + "lodash.bind": "4.2.1", + "lodash.defaults": "4.2.0", + "lodash.filter": "4.6.0", + "lodash.flatten": "4.4.0", + "lodash.foreach": "4.5.0", + "lodash.map": "4.6.0", + "lodash.merge": "4.6.1", + "lodash.pick": "4.4.0", + "lodash.reduce": "4.6.0", + "lodash.reject": "4.6.0", + "lodash.some": "4.6.0" + } + }, + "chokidar": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz", + "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=", + "dev": true, + "optional": true, + "requires": { + "anymatch": "1.3.2", + "async-each": "1.0.1", + "fsevents": "1.2.3", + "glob-parent": "2.0.0", + "inherits": "2.0.3", + "is-binary-path": "1.0.1", + "is-glob": "2.0.1", + "path-is-absolute": "1.0.1", + "readdirp": "2.1.0" + } + }, + "ci-info": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-1.1.3.tgz", + "integrity": "sha512-SK/846h/Rcy8q9Z9CAwGBLfCJ6EkjJWdpelWDufQpqVDYq2Wnnv8zlSO6AMQap02jvhVruKKpEtQOufo3pFhLg==", + "dev": true + }, + "circular-json": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz", + "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==", + "dev": true + }, + "class-utils": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", + "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", + "dev": true, + "requires": { + "arr-union": "3.1.0", + "define-property": "0.2.5", + "isobject": "3.0.1", + "static-extend": "0.1.2" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "clean-stack": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-1.3.0.tgz", + "integrity": "sha1-noIVAa6XmYbEax1m0tQy2y/UrjE=", + "dev": true + }, + "cli-boxes": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-1.0.0.tgz", + "integrity": "sha1-T6kXw+WclKAEzWH47lCdplFocUM=", + "dev": true + }, + "cli-color": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/cli-color/-/cli-color-0.3.2.tgz", + "integrity": "sha1-dfpfcowwjMSsWUsF4GzF2A2szYY=", + "dev": true, + "requires": { + "d": "0.1.1", + "es5-ext": "0.10.45", + "memoizee": "0.3.10", + "timers-ext": "0.1.5" + } + }, + "cli-cursor": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", + "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", + "dev": true, + "requires": { + "restore-cursor": "2.0.0" + } + }, + "cli-width": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz", + "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=", + "dev": true + }, + "clui": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/clui/-/clui-0.3.6.tgz", + "integrity": "sha512-Z4UbgZILlIAjkEkZiDOa2aoYjohKx7fa6DxIh6cE9A6WNWZ61iXfQc6CmdC9SKdS5nO0P0UyQ+WfoXfB65e3HQ==", + "dev": true, + "requires": { + "cli-color": "0.3.2" + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=" + }, + "collection-visit": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", + "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", + "dev": true, + "requires": { + "map-visit": "1.0.0", + "object-visit": "1.0.1" + } + }, + "color-convert": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.1.tgz", + "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "dev": true + }, + "colors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.0.3.tgz", + "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=" + }, + "combined-stream": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.6.tgz", + "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", + "requires": { + "delayed-stream": "1.0.0" + } + }, + "commander": { + "version": "2.16.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.16.0.tgz", + "integrity": "sha512-sVXqklSaotK9at437sFlFpyOcJonxe0yST/AG9DkQKUdIE6IqGIMv4SfAQSKaJbSdVEJYItASCrBiVQHq1HQew==" + }, + "component-emitter": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz", + "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=", + "dev": true + }, + "compress-commons": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-1.2.2.tgz", + "integrity": "sha1-UkqfEJA/OoEzibAiXSfEi7dRiQ8=", + "requires": { + "buffer-crc32": "0.2.13", + "crc32-stream": "2.0.0", + "normalize-path": "2.1.1", + "readable-stream": "2.3.6" + } + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "requires": { + "buffer-from": "1.1.1", + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "typedarray": "0.0.6" + } + }, + "config-chain": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.11.tgz", + "integrity": "sha1-q6CXR9++TD5w52am5BWG4YWfxvI=", + "dev": true, + "requires": { + "ini": "1.3.5", + "proto-list": "1.2.4" + } + }, + "configstore": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/configstore/-/configstore-3.1.2.tgz", + "integrity": "sha512-vtv5HtGjcYUgFrXc6Kx747B83MRRVS5R1VTEQoXvuP+kMI+if6uywV0nDGoiydJRy4yk7h9od5Og0kxx4zUXmw==", + "dev": true, + "requires": { + "dot-prop": "4.2.0", + "graceful-fs": "4.1.11", + "make-dir": "1.2.0", + "unique-string": "1.0.0", + "write-file-atomic": "2.3.0", + "xdg-basedir": "3.0.0" + } + }, + "connected-domain": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/connected-domain/-/connected-domain-1.0.0.tgz", + "integrity": "sha1-v+dyOMdL5FOnnwy2BY3utPI1jpM=", + "dev": true + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=" + }, + "content-disposition": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz", + "integrity": "sha1-DPaLud318r55YcOoUXjLhdunjLQ=" + }, + "content-type": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", + "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==" + }, + "convert-source-map": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz", + "integrity": "sha1-uCeAl7m8IpNl3lxiz1/K7YtVmeU=", + "dev": true + }, + "cookie": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz", + "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=" + }, + "cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw=" + }, + "copy-descriptor": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", + "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", + "dev": true + }, + "core-js": { + "version": "2.5.6", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.6.tgz", + "integrity": "sha512-lQUVfQi0aLix2xpyjrrJEvfuYCqPc/HwmTKsC/VNf8q0zsjX7SQZtp4+oRONN5Tsur9GDETPjj+Ub2iDiGZfSQ==" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "crc": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz", + "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==", + "requires": { + "buffer": "5.2.0" + }, + "dependencies": { + "buffer": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.2.0.tgz", + "integrity": "sha512-nUJyfChH7PMJy75eRDCCKtszSEFokUNXC1hNVSe+o+VdcgvDPLs20k3v8UXI8ruRYAJiYtyRea8mYyqPxoHWDw==", + "requires": { + "base64-js": "1.3.0", + "ieee754": "1.1.8" + } + } + } + }, + "crc32-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-2.0.0.tgz", + "integrity": "sha1-483TtN8xaN10494/u8t7KX/pCPQ=", + "requires": { + "crc": "3.8.0", + "readable-stream": "2.3.6" + } + }, + "create-error-class": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz", + "integrity": "sha1-Br56vvlHo/FKMP1hBnHUAbyot7Y=", + "dev": true, + "requires": { + "capture-stack-trace": "1.0.0" + } + }, + "cross-env": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-5.2.0.tgz", + "integrity": "sha512-jtdNFfFW1hB7sMhr/H6rW1Z45LFqyI431m3qU6bFXcQ3Eh7LtBuG3h74o7ohHZ3crrRkkqHlo4jYHFPcjroANg==", + "dev": true, + "requires": { + "cross-spawn": "6.0.5", + "is-windows": "1.0.2" + }, + "dependencies": { + "cross-spawn": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", + "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==", + "dev": true, + "requires": { + "nice-try": "1.0.4", + "path-key": "2.0.1", + "semver": "5.5.0", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + } + } + }, + "cross-spawn": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", + "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", + "dev": true, + "requires": { + "lru-cache": "4.1.2", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + }, + "cryptiles": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/cryptiles/-/cryptiles-3.1.2.tgz", + "integrity": "sha1-qJ+7Ig9c4l7FboxKqKT9e1sNKf4=", + "requires": { + "boom": "5.2.0" + }, + "dependencies": { + "boom": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/boom/-/boom-5.2.0.tgz", + "integrity": "sha512-Z5BTk6ZRe4tXXQlkqftmsAUANpXmuwlsF5Oov8ThoMbQRzdGTA1ngYRW160GexgOgjsFOKJz0LYhoNi+2AMBUw==", + "requires": { + "hoek": "4.2.1" + } + } + } + }, + "crypto-random-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-1.0.0.tgz", + "integrity": "sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=", + "dev": true + }, + "css-select": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-1.2.0.tgz", + "integrity": "sha1-KzoRBTnFNV8c2NMUYj6HCxIeyFg=", + "dev": true, + "requires": { + "boolbase": "1.0.0", + "css-what": "2.1.0", + "domutils": "1.5.1", + "nth-check": "1.0.1" + } + }, + "css-what": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-2.1.0.tgz", + "integrity": "sha1-lGfQMsOM+u+58teVASUwYvh/ob0=", + "dev": true + }, + "cycle": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cycle/-/cycle-1.0.3.tgz", + "integrity": "sha1-IegLK+hYD5i0aPN5QwZisEbDStI=" + }, + "d": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/d/-/d-0.1.1.tgz", + "integrity": "sha1-2hhMU10Y2O57oqoim5FACfrhEwk=", + "dev": true, + "requires": { + "es5-ext": "0.10.45" + } + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "requires": { + "assert-plus": "1.0.0" + } + }, + "data-uri-to-buffer": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-1.2.0.tgz", + "integrity": "sha512-vKQ9DTQPN1FLYiiEEOQ6IBGFqvjCa5rSK3cWMy/Nespm5d/x3dGFT9UBZnkLxCwua/IXBi2TYnwTEpsOvhC4UQ==" + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "requires": { + "ms": "2.0.0" + } + }, + "decode-uri-component": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", + "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=", + "dev": true + }, + "decompress": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/decompress/-/decompress-4.2.0.tgz", + "integrity": "sha1-eu3YVCflqS2s/lVnSnxQXpbQH50=", + "dev": true, + "requires": { + "decompress-tar": "4.1.1", + "decompress-tarbz2": "4.1.1", + "decompress-targz": "4.1.1", + "decompress-unzip": "4.0.1", + "graceful-fs": "4.1.11", + "make-dir": "1.2.0", + "pify": "2.3.0", + "strip-dirs": "2.1.0" + } + }, + "decompress-response": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz", + "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=", + "dev": true, + "requires": { + "mimic-response": "1.0.0" + } + }, + "decompress-tar": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-tar/-/decompress-tar-4.1.1.tgz", + "integrity": "sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==", + "dev": true, + "requires": { + "file-type": "5.2.0", + "is-stream": "1.1.0", + "tar-stream": "1.6.1" + } + }, + "decompress-tarbz2": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz", + "integrity": "sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==", + "dev": true, + "requires": { + "decompress-tar": "4.1.1", + "file-type": "6.2.0", + "is-stream": "1.1.0", + "seek-bzip": "1.0.5", + "unbzip2-stream": "1.2.5" + }, + "dependencies": { + "file-type": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-6.2.0.tgz", + "integrity": "sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==", + "dev": true + } + } + }, + "decompress-targz": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-targz/-/decompress-targz-4.1.1.tgz", + "integrity": "sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==", + "dev": true, + "requires": { + "decompress-tar": "4.1.1", + "file-type": "5.2.0", + "is-stream": "1.1.0" + } + }, + "decompress-unzip": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/decompress-unzip/-/decompress-unzip-4.0.1.tgz", + "integrity": "sha1-3qrM39FK6vhVePczroIQ+bSEj2k=", + "dev": true, + "requires": { + "file-type": "3.9.0", + "get-stream": "2.3.1", + "pify": "2.3.0", + "yauzl": "2.10.0" + }, + "dependencies": { + "file-type": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-3.9.0.tgz", + "integrity": "sha1-JXoHg4TR24CHvESdEH1SpSZyuek=", + "dev": true + }, + "get-stream": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-2.3.1.tgz", + "integrity": "sha1-Xzj5PzRgCWZu4BUKBUFn+Rvdld4=", + "dev": true, + "requires": { + "object-assign": "4.1.1", + "pinkie-promise": "2.0.1" + } + } + } + }, + "deep-diff": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/deep-diff/-/deep-diff-1.0.1.tgz", + "integrity": "sha512-Vkn+eQK6H63gObVi3KWmPMb4RdzMpfdp5t0HNppq8Oc7xbwmvBy5BIHsEYSXOiS9Lr/W+3lF020zyPTsGfea4g==", + "dev": true + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=" + }, + "deepcopy": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/deepcopy/-/deepcopy-1.0.0.tgz", + "integrity": "sha512-WJrecobaoqqgQHtvRI2/VCzWoWXPAnFYyAkF/spmL46lZMnd0gW0gLGuyeFVSrqt2B3s0oEEj6i+j2L/2QiS4g==", + "requires": { + "type-detect": "4.0.8" + } + }, + "define-properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz", + "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", + "dev": true, + "requires": { + "foreach": "2.0.5", + "object-keys": "1.0.12" + } + }, + "define-property": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", + "dev": true, + "requires": { + "is-descriptor": "1.0.2", + "isobject": "3.0.1" + }, + "dependencies": { + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true + } + } + }, + "degenerator": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-1.0.4.tgz", + "integrity": "sha1-/PSQo37OJmRk2cxDGrmMWBnO0JU=", + "requires": { + "ast-types": "0.11.3", + "escodegen": "1.9.1", + "esprima": "3.1.3" + } + }, + "del": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/del/-/del-2.2.2.tgz", + "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=", + "dev": true, + "requires": { + "globby": "5.0.0", + "is-path-cwd": "1.0.0", + "is-path-in-cwd": "1.0.1", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "rimraf": "2.6.2" + } + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=" + }, + "depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=" + }, + "destroy": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz", + "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=" + }, + "detect-indent": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz", + "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=", + "dev": true, + "requires": { + "repeating": "2.0.1" + } + }, + "dicer": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/dicer/-/dicer-0.2.5.tgz", + "integrity": "sha1-WZbAhrszIYyBLAkL3cCc0S+stw8=", + "requires": { + "readable-stream": "1.1.14", + "streamsearch": "0.1.2" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "dir-glob": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-2.0.0.tgz", + "integrity": "sha512-37qirFDz8cA5fimp9feo43fSuRo2gHwaIn6dXL8Ber1dGwUosDrGZeCCXq57WnIqE4aQ+u3eQZzsk1yOzhdwag==", + "dev": true, + "requires": { + "arrify": "1.0.1", + "path-type": "3.0.0" + } + }, + "docopt": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/docopt/-/docopt-0.6.2.tgz", + "integrity": "sha1-so6eIiDaXsSffqW7JKR3h0Be6xE=", + "dev": true + }, + "doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dev": true, + "requires": { + "esutils": "2.0.2" + } + }, + "dom-serializer": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.0.tgz", + "integrity": "sha1-BzxpdUbOB4DOI75KKOKT5AvDDII=", + "dev": true, + "requires": { + "domelementtype": "1.1.3", + "entities": "1.1.1" + }, + "dependencies": { + "domelementtype": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.1.3.tgz", + "integrity": "sha1-vSh3PiZCiBrsUVRJJCmcXNgiGFs=", + "dev": true + } + } + }, + "domelementtype": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.0.tgz", + "integrity": "sha1-sXrtguirWeUt2cGbF1bg/BhyBMI=", + "dev": true + }, + "domhandler": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.4.2.tgz", + "integrity": "sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==", + "dev": true, + "requires": { + "domelementtype": "1.3.0" + } + }, + "domutils": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.5.1.tgz", + "integrity": "sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=", + "dev": true, + "requires": { + "dom-serializer": "0.1.0", + "domelementtype": "1.3.0" + } + }, + "dot-prop": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-4.2.0.tgz", + "integrity": "sha512-tUMXrxlExSW6U2EXiiKGSBVdYgtV8qlHL+C10TsW4PURY/ic+eaysnSkwB4kA/mBlCyy/IKDJ+Lc3wbWeaXtuQ==", + "dev": true, + "requires": { + "is-obj": "1.0.1" + } + }, + "double-ended-queue": { + "version": "2.1.0-0", + "resolved": "https://registry.npmjs.org/double-ended-queue/-/double-ended-queue-2.1.0-0.tgz", + "integrity": "sha1-ED01J/0xUo9AGIEwyEHv3XgmTlw=" + }, + "downcache": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/downcache/-/downcache-0.0.9.tgz", + "integrity": "sha1-eQuwQkaJE2EVzpPyqhWUbG2AbQ4=", + "dev": true, + "requires": { + "extend": "3.0.1", + "graceful-fs": "4.1.11", + "limiter": "1.1.3", + "mkdirp": "0.5.1", + "npmlog": "2.0.4", + "request": "2.85.0", + "rimraf": "2.6.2" + }, + "dependencies": { + "gauge": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-1.2.7.tgz", + "integrity": "sha1-6c7FSD09TuDvRLYKfZnkk14TbZM=", + "dev": true, + "requires": { + "ansi": "0.3.1", + "has-unicode": "2.0.1", + "lodash.pad": "4.5.1", + "lodash.padend": "4.6.1", + "lodash.padstart": "4.6.1" + } + }, + "npmlog": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-2.0.4.tgz", + "integrity": "sha1-mLUlMPJRTKkNCexbIsiEZyI3VpI=", + "dev": true, + "requires": { + "ansi": "0.3.1", + "are-we-there-yet": "1.1.4", + "gauge": "1.2.7" + } + } + } + }, + "download": { + "version": "6.2.5", + "resolved": "https://registry.npmjs.org/download/-/download-6.2.5.tgz", + "integrity": "sha512-DpO9K1sXAST8Cpzb7kmEhogJxymyVUd5qz/vCOSyvwtp2Klj2XcDt5YUuasgxka44SxF0q5RriKIwJmQHG2AuA==", + "dev": true, + "requires": { + "caw": "2.0.1", + "content-disposition": "0.5.2", + "decompress": "4.2.0", + "ext-name": "5.0.0", + "file-type": "5.2.0", + "filenamify": "2.1.0", + "get-stream": "3.0.0", + "got": "7.1.0", + "make-dir": "1.2.0", + "p-event": "1.3.0", + "pify": "3.0.0" + }, + "dependencies": { + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", + "dev": true + } + } + }, + "duplexer": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz", + "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=", + "dev": true + }, + "duplexer3": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=", + "dev": true + }, + "ecc-jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz", + "integrity": "sha1-D8c6ntXw1Tw4GTOYUj735UN3dQU=", + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "ecdsa-sig-formatter": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.10.tgz", + "integrity": "sha1-HFlQAPBKiJffuFAAiSoPTDOvhsM=", + "requires": { + "safe-buffer": "5.1.2" + } + }, + "ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=" + }, + "electron-to-chromium": { + "version": "1.3.45", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.45.tgz", + "integrity": "sha1-RYrBscXHYM6IEaFtK/vZfsMLr7g=", + "dev": true + }, + "encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=" + }, + "end-of-stream": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz", + "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", + "requires": { + "once": "1.4.0" + } + }, + "entities": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.1.tgz", + "integrity": "sha1-blwtClYhtdra7O+AuQ7ftc13cvA=", + "dev": true + }, + "es-abstract": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz", + "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==", + "dev": true, + "requires": { + "es-to-primitive": "1.1.1", + "function-bind": "1.1.1", + "has": "1.0.3", + "is-callable": "1.1.3", + "is-regex": "1.0.4" + } + }, + "es-to-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz", + "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", + "dev": true, + "requires": { + "is-callable": "1.1.3", + "is-date-object": "1.0.1", + "is-symbol": "1.0.1" + } + }, + "es5-ext": { + "version": "0.10.45", + "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.45.tgz", + "integrity": "sha512-FkfM6Vxxfmztilbxxz5UKSD4ICMf5tSpRFtDNtkAhOxZ0EKtX6qwmXNyH/sFyIbX2P/nU5AMiA9jilWsUGJzCQ==", + "dev": true, + "requires": { + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1", + "next-tick": "1.0.0" + } + }, + "es6-iterator": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", + "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", + "dev": true, + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.45", + "es6-symbol": "3.1.1" + }, + "dependencies": { + "d": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz", + "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", + "dev": true, + "requires": { + "es5-ext": "0.10.45" + } + } + } + }, + "es6-promise": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.4.tgz", + "integrity": "sha512-/NdNZVJg+uZgtm9eS3O6lrOLYmQag2DjdEXuPaHlZ6RuVqgqaVZfgYCepEIKsLqwdQArOPtC3XzRLqGGfT8KQQ==" + }, + "es6-promisify": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz", + "integrity": "sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=", + "requires": { + "es6-promise": "4.2.4" + } + }, + "es6-symbol": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.1.tgz", + "integrity": "sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc=", + "dev": true, + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.45" + }, + "dependencies": { + "d": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz", + "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", + "dev": true, + "requires": { + "es5-ext": "0.10.45" + } + } + } + }, + "es6-weak-map": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-0.1.4.tgz", + "integrity": "sha1-cGzvnpmqI2undmwjnIueKG6n0ig=", + "dev": true, + "requires": { + "d": "0.1.1", + "es5-ext": "0.10.45", + "es6-iterator": "0.1.3", + "es6-symbol": "2.0.1" + }, + "dependencies": { + "es6-iterator": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-0.1.3.tgz", + "integrity": "sha1-1vWLjE/EE8JJtLqhl2j45NfIlE4=", + "dev": true, + "requires": { + "d": "0.1.1", + "es5-ext": "0.10.45", + "es6-symbol": "2.0.1" + } + }, + "es6-symbol": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-2.0.1.tgz", + "integrity": "sha1-dhtcZ8/U8dGK+yNPaR1nhoLLO/M=", + "dev": true, + "requires": { + "d": "0.1.1", + "es5-ext": "0.10.45" + } + } + } + }, + "escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=" + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=", + "dev": true + }, + "escodegen": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.9.1.tgz", + "integrity": "sha1-264X75bI5L7bE1b0UE+kzC98t+I=", + "requires": { + "esprima": "3.1.3", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "optionator": "0.8.2", + "source-map": "0.6.1" + } + }, + "eslint": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-5.0.0.tgz", + "integrity": "sha512-MA0YWJLeK7BPEBxJCINvKnQdKpeTwbac3Xonh0PPFjWYZkowZf+Xl30lJWJ/BWOqFQdAdPcyOh0aBqlbH6ojAg==", + "dev": true, + "requires": { + "ajv": "6.5.1", + "babel-code-frame": "6.26.0", + "chalk": "2.4.1", + "cross-spawn": "6.0.5", + "debug": "3.1.0", + "doctrine": "2.1.0", + "eslint-scope": "4.0.0", + "eslint-visitor-keys": "1.0.0", + "espree": "4.0.0", + "esquery": "1.0.1", + "esutils": "2.0.2", + "file-entry-cache": "2.0.0", + "functional-red-black-tree": "1.0.1", + "glob": "7.1.2", + "globals": "11.7.0", + "ignore": "3.3.10", + "imurmurhash": "0.1.4", + "inquirer": "5.2.0", + "is-resolvable": "1.1.0", + "js-yaml": "3.12.0", + "json-stable-stringify-without-jsonify": "1.0.1", + "levn": "0.3.0", + "lodash": "4.17.5", + "minimatch": "3.0.4", + "mkdirp": "0.5.1", + "natural-compare": "1.4.0", + "optionator": "0.8.2", + "path-is-inside": "1.0.2", + "pluralize": "7.0.0", + "progress": "2.0.0", + "regexpp": "1.1.0", + "require-uncached": "1.0.3", + "semver": "5.5.0", + "string.prototype.matchall": "2.0.0", + "strip-ansi": "4.0.0", + "strip-json-comments": "2.0.1", + "table": "4.0.3", + "text-table": "0.2.0" + }, + "dependencies": { + "ajv": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.5.1.tgz", + "integrity": "sha512-pgZos1vgOHDiC7gKNbZW8eKvCnNXARv2oqrGQT7Hzbq5Azp7aZG6DJzADnkuSq7RH6qkXp4J/m68yPX/2uBHyQ==", + "dev": true, + "requires": { + "fast-deep-equal": "2.0.1", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.4.1", + "uri-js": "4.2.2" + } + }, + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "cross-spawn": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", + "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==", + "dev": true, + "requires": { + "nice-try": "1.0.4", + "path-key": "2.0.1", + "semver": "5.5.0", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + }, + "eslint-scope": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.0.tgz", + "integrity": "sha512-1G6UTDi7Jc1ELFwnR58HV4fK9OQK4S6N985f166xqXxpjU6plxFISJa2Ba9KCQuFa8RCnj/lSFJbHo7UFDBnUA==", + "dev": true, + "requires": { + "esrecurse": "4.2.1", + "estraverse": "4.2.0" + } + }, + "fast-deep-equal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz", + "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=", + "dev": true + }, + "globals": { + "version": "11.7.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.7.0.tgz", + "integrity": "sha512-K8BNSPySfeShBQXsahYB/AbbWruVOTyVpgoIDnl8odPpeSfP2J5QO2oLFFdl2j7GfDCtZj2bMKar2T49itTPCg==", + "dev": true + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "dev": true, + "requires": { + "has-flag": "3.0.0" + } + } + } + }, + "eslint-plugin-flowtype": { + "version": "2.46.3", + "resolved": "https://registry.npmjs.org/eslint-plugin-flowtype/-/eslint-plugin-flowtype-2.46.3.tgz", + "integrity": "sha512-VpnNeC4E6t2E2NCw8Oveda91p8CPEaujZURC1KhHe4lBRZJla3o0DVvZu1QGXQZO1ZJ4vUmy3TCp95PqGvIZgQ==", + "dev": true, + "requires": { + "lodash": "4.17.5" + } + }, + "eslint-scope": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.1.tgz", + "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=", + "dev": true, + "requires": { + "esrecurse": "4.2.1", + "estraverse": "4.2.0" + } + }, + "eslint-visitor-keys": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz", + "integrity": "sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==", + "dev": true + }, + "espree": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-4.0.0.tgz", + "integrity": "sha512-kapdTCt1bjmspxStVKX6huolXVV5ZfyZguY1lcfhVVZstce3bqxH9mcLzNn3/mlgW6wQ732+0fuG9v7h0ZQoKg==", + "dev": true, + "requires": { + "acorn": "5.7.1", + "acorn-jsx": "4.1.1" + } + }, + "esprima": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", + "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=" + }, + "esquery": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.1.tgz", + "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==", + "dev": true, + "requires": { + "estraverse": "4.2.0" + } + }, + "esrecurse": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz", + "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==", + "dev": true, + "requires": { + "estraverse": "4.2.0" + } + }, + "estraverse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", + "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=" + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=" + }, + "etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=" + }, + "event-emitter": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz", + "integrity": "sha1-34xp7vFkeSPHFXuc6DhAYQsCzDk=", + "dev": true, + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.45" + }, + "dependencies": { + "d": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz", + "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", + "dev": true, + "requires": { + "es5-ext": "0.10.45" + } + } + } + }, + "event-stream": { + "version": "3.3.4", + "resolved": "http://registry.npmjs.org/event-stream/-/event-stream-3.3.4.tgz", + "integrity": "sha1-SrTJoPWlTbkzi0w02Gv86PSzVXE=", + "dev": true, + "requires": { + "duplexer": "0.1.1", + "from": "0.1.7", + "map-stream": "0.1.0", + "pause-stream": "0.0.11", + "split": "0.3.3", + "stream-combiner": "0.0.4", + "through": "2.3.8" + }, + "dependencies": { + "split": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/split/-/split-0.3.3.tgz", + "integrity": "sha1-zQ7qXmOiEd//frDwkcQTPi0N0o8=", + "dev": true, + "requires": { + "through": "2.3.8" + } + } + } + }, + "events": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz", + "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=" + }, + "execa": { + "version": "0.10.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.10.0.tgz", + "integrity": "sha512-7XOMnz8Ynx1gGo/3hyV9loYNPWM94jG3+3T3Y8tsfSstFmETmENCMU/A/zj8Lyaj1lkgEepKepvd6240tBRvlw==", + "dev": true, + "requires": { + "cross-spawn": "6.0.5", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" + }, + "dependencies": { + "cross-spawn": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", + "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==", + "dev": true, + "requires": { + "nice-try": "1.0.4", + "path-key": "2.0.1", + "semver": "5.5.0", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + } + } + }, + "expand-brackets": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz", + "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=", + "dev": true, + "optional": true, + "requires": { + "is-posix-bracket": "0.1.1" + } + }, + "expand-range": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz", + "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=", + "dev": true, + "optional": true, + "requires": { + "fill-range": "2.2.4" + } + }, + "express": { + "version": "4.16.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.16.2.tgz", + "integrity": "sha1-41xt/i1kt9ygpc1PIXgb4ymeB2w=", + "requires": { + "accepts": "1.3.5", + "array-flatten": "1.1.1", + "body-parser": "1.18.2", + "content-disposition": "0.5.2", + "content-type": "1.0.4", + "cookie": "0.3.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "1.1.2", + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "etag": "1.8.1", + "finalhandler": "1.1.0", + "fresh": "0.5.2", + "merge-descriptors": "1.0.1", + "methods": "1.1.2", + "on-finished": "2.3.0", + "parseurl": "1.3.2", + "path-to-regexp": "0.1.7", + "proxy-addr": "2.0.3", + "qs": "6.5.1", + "range-parser": "1.2.0", + "safe-buffer": "5.1.1", + "send": "0.16.1", + "serve-static": "1.13.1", + "setprototypeof": "1.1.0", + "statuses": "1.3.1", + "type-is": "1.6.16", + "utils-merge": "1.0.1", + "vary": "1.1.2" + }, + "dependencies": { + "body-parser": { + "version": "1.18.2", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz", + "integrity": "sha1-h2eKGdhLR9hZuDGZvVm84iKxBFQ=", + "requires": { + "bytes": "3.0.0", + "content-type": "1.0.4", + "debug": "2.6.9", + "depd": "1.1.2", + "http-errors": "1.6.3", + "iconv-lite": "0.4.19", + "on-finished": "2.3.0", + "qs": "6.5.1", + "raw-body": "2.3.2", + "type-is": "1.6.16" + } + }, + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "iconv-lite": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", + "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==" + }, + "qs": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.1.tgz", + "integrity": "sha512-eRzhrN1WSINYCDCbrz796z37LOe3m5tmW7RQf6oBntukAG1nmovJvhnwHHRMAfeoItc1m2Hk02WER2aQ/iqs+A==" + }, + "raw-body": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.2.tgz", + "integrity": "sha1-vNYMd9Prk83gBQKVw/N5OJvIj4k=", + "requires": { + "bytes": "3.0.0", + "http-errors": "1.6.2", + "iconv-lite": "0.4.19", + "unpipe": "1.0.0" + }, + "dependencies": { + "depd": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz", + "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k=" + }, + "http-errors": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz", + "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=", + "requires": { + "depd": "1.1.1", + "inherits": "2.0.3", + "setprototypeof": "1.0.3", + "statuses": "1.3.1" + } + }, + "setprototypeof": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz", + "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ=" + } + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "statuses": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.3.1.tgz", + "integrity": "sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=" + } + } + }, + "ext-list": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/ext-list/-/ext-list-2.2.2.tgz", + "integrity": "sha512-u+SQgsubraE6zItfVA0tBuCBhfU9ogSRnsvygI7wht9TS510oLkBRXBsqopeUG/GBOIQyKZO9wjTqIu/sf5zFA==", + "dev": true, + "requires": { + "mime-db": "1.33.0" + } + }, + "ext-name": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ext-name/-/ext-name-5.0.0.tgz", + "integrity": "sha512-yblEwXAbGv1VQDmow7s38W77hzAgJAO50ztBLMcUyUBfxv1HC+LGwtiEN+Co6LtlqT/5uwVOxsD4TNIilWhwdQ==", + "dev": true, + "requires": { + "ext-list": "2.2.2", + "sort-keys-length": "1.0.1" + } + }, + "extend": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz", + "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=" + }, + "extend-shallow": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", + "dev": true, + "requires": { + "assign-symbols": "1.0.0", + "is-extendable": "1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", + "dev": true, + "requires": { + "is-plain-object": "2.0.4" + } + } + } + }, + "external-editor": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz", + "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==", + "dev": true, + "requires": { + "chardet": "0.4.2", + "iconv-lite": "0.4.23", + "tmp": "0.0.33" + } + }, + "extglob": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz", + "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=", + "dev": true, + "optional": true, + "requires": { + "is-extglob": "1.0.0" + } + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + }, + "eyes": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz", + "integrity": "sha1-Ys8SAjTGg3hdkCNIqADvPgzCC8A=" + }, + "fast-deep-equal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", + "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=" + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=" + }, + "fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=", + "dev": true, + "requires": { + "pend": "1.2.0" + } + }, + "figures": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", + "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5" + } + }, + "file-entry-cache": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz", + "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", + "dev": true, + "requires": { + "flat-cache": "1.3.0", + "object-assign": "4.1.1" + } + }, + "file-type": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-5.2.0.tgz", + "integrity": "sha1-LdvqfHP/42No365J3DOMBYwritY=", + "dev": true + }, + "file-uri-to-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", + "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==" + }, + "filename-regex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz", + "integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=", + "dev": true, + "optional": true + }, + "filename-reserved-regex": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/filename-reserved-regex/-/filename-reserved-regex-2.0.0.tgz", + "integrity": "sha1-q/c9+rc10EVECr/qLZHzieu/oik=", + "dev": true + }, + "filenamify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/filenamify/-/filenamify-2.1.0.tgz", + "integrity": "sha512-ICw7NTT6RsDp2rnYKVd8Fu4cr6ITzGy3+u4vUujPkabyaz+03F24NWEX7fs5fp+kBonlaqPH8fAO2NM+SXt/JA==", + "dev": true, + "requires": { + "filename-reserved-regex": "2.0.0", + "strip-outer": "1.0.1", + "trim-repeated": "1.0.0" + } + }, + "fill-range": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz", + "integrity": "sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==", + "dev": true, + "optional": true, + "requires": { + "is-number": "2.1.0", + "isobject": "2.1.0", + "randomatic": "3.0.0", + "repeat-element": "1.1.2", + "repeat-string": "1.6.1" + } + }, + "finalhandler": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.0.tgz", + "integrity": "sha1-zgtoVbRYU+eRsvzGgARtiCU91/U=", + "requires": { + "debug": "2.6.9", + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "on-finished": "2.3.0", + "parseurl": "1.3.2", + "statuses": "1.3.1", + "unpipe": "1.0.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "statuses": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.3.1.tgz", + "integrity": "sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=" + } + } + }, + "find-root": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/find-root/-/find-root-0.1.2.tgz", + "integrity": "sha1-mNImfP8ZFsyvJ0OzoO6oHXnX3NE=", + "dev": true + }, + "flat-cache": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.0.tgz", + "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=", + "dev": true, + "requires": { + "circular-json": "0.3.3", + "del": "2.2.2", + "graceful-fs": "4.1.11", + "write": "0.2.1" + } + }, + "flow-bin": { + "version": "0.76.0", + "resolved": "https://registry.npmjs.org/flow-bin/-/flow-bin-0.76.0.tgz", + "integrity": "sha512-ywyEEEDYuItrkpx9HqRhuY78rXYbaWiNZSWgaI0KUGGeOldaTEbCZXosspxTEKqmQTCBW1/02Z2K0kC9C6hqzQ==", + "dev": true + }, + "for-in": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", + "dev": true + }, + "for-own": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz", + "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=", + "dev": true, + "optional": true, + "requires": { + "for-in": "1.0.2" + } + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", + "dev": true + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.2.tgz", + "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", + "requires": { + "asynckit": "0.4.0", + "combined-stream": "1.0.6", + "mime-types": "2.1.18" + } + }, + "forwarded": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz", + "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ=" + }, + "fragment-cache": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", + "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", + "dev": true, + "requires": { + "map-cache": "0.2.2" + } + }, + "fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=" + }, + "from": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz", + "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4=", + "dev": true + }, + "fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==" + }, + "fs-extra": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.3.tgz", + "integrity": "sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "jsonfile": "4.0.0", + "universalify": "0.1.2" + } + }, + "fs-readdir-recursive": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz", + "integrity": "sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==", + "dev": true + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "fsevents": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.3.tgz", + "integrity": "sha512-X+57O5YkDTiEQGiw8i7wYc2nQgweIekqkepI8Q3y4wVlurgBt2SuwxTeYUYMZIGpLZH3r/TsMjczCMXE5ZOt7Q==", + "dev": true, + "optional": true, + "requires": { + "nan": "2.10.0", + "node-pre-gyp": "0.9.1" + }, + "dependencies": { + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", + "dev": true, + "optional": true + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true + }, + "aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==", + "dev": true, + "optional": true + }, + "are-we-there-yet": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.4.tgz", + "integrity": "sha1-u13KOCu5TwXhUZQ3PRb9O6HKEQ0=", + "dev": true, + "optional": true, + "requires": { + "delegates": "1.0.0", + "readable-stream": "2.3.6" + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", + "dev": true + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "chownr": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.0.1.tgz", + "integrity": "sha1-4qdQQqlVGQi+vSW4Uj1fl2nXkYE=", + "dev": true, + "optional": true + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", + "dev": true + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=", + "dev": true + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", + "dev": true, + "optional": true + }, + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "optional": true, + "requires": { + "ms": "2.0.0" + } + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true, + "optional": true + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=", + "dev": true, + "optional": true + }, + "detect-libc": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz", + "integrity": "sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=", + "dev": true, + "optional": true + }, + "fs-minipass": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.5.tgz", + "integrity": "sha512-JhBl0skXjUPCFH7x6x61gQxrKyXsxB5gcgePLZCwfyCGGsTISMoIeObbrvVeP6Xmyaudw4TT43qV2Gz+iyd2oQ==", + "dev": true, + "optional": true, + "requires": { + "minipass": "2.2.4" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", + "dev": true, + "optional": true + }, + "gauge": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", + "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", + "dev": true, + "optional": true, + "requires": { + "aproba": "1.2.0", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.2" + } + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "dev": true, + "optional": true, + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=", + "dev": true, + "optional": true + }, + "iconv-lite": { + "version": "0.4.21", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.21.tgz", + "integrity": "sha512-En5V9za5mBt2oUA03WGD3TwDv0MKAruqsuxstbMUZaj9W9k/m1CV/9py3l0L5kw9Bln8fdHQmzHSYtvpvTLpKw==", + "dev": true, + "optional": true, + "requires": { + "safer-buffer": "2.1.2" + } + }, + "ignore-walk": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.1.tgz", + "integrity": "sha512-DTVlMx3IYPe0/JJcYP7Gxg7ttZZu3IInhuEhbchuqneY9wWe5Ojy2mXLBaQFUQmo0AW2r3qG7m1mg86js+gnlQ==", + "dev": true, + "optional": true, + "requires": { + "minimatch": "3.0.4" + } + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "dev": true, + "optional": true, + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true, + "optional": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "requires": { + "brace-expansion": "1.1.11" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", + "dev": true + }, + "minipass": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-2.2.4.tgz", + "integrity": "sha512-hzXIWWet/BzWhYs2b+u7dRHlruXhwdgvlTMDKC6Cb1U7ps6Ac6yQlR39xsbjWJE377YTCtKwIXIpJ5oP+j5y8g==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1", + "yallist": "3.0.2" + } + }, + "minizlib": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-1.1.0.tgz", + "integrity": "sha512-4T6Ur/GctZ27nHfpt9THOdRZNgyJ9FZchYO1ceg5S8Q3DNLCKYy44nCZzgCJgcvx2UM8czmqak5BCxJMrq37lA==", + "dev": true, + "optional": true, + "requires": { + "minipass": "2.2.4" + } + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "dev": true, + "requires": { + "minimist": "0.0.8" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true, + "optional": true + }, + "needle": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/needle/-/needle-2.2.0.tgz", + "integrity": "sha512-eFagy6c+TYayorXw/qtAdSvaUpEbBsDwDyxYFgLZ0lTojfH7K+OdBqAF7TAFwDokJaGpubpSGG0wO3iC0XPi8w==", + "dev": true, + "optional": true, + "requires": { + "debug": "2.6.9", + "iconv-lite": "0.4.21", + "sax": "1.2.4" + } + }, + "node-pre-gyp": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.9.1.tgz", + "integrity": "sha1-8RwHUW3ZL4cZnbx+GDjqt81WyeA=", + "dev": true, + "optional": true, + "requires": { + "detect-libc": "1.0.3", + "mkdirp": "0.5.1", + "needle": "2.2.0", + "nopt": "4.0.1", + "npm-packlist": "1.1.10", + "npmlog": "4.1.2", + "rc": "1.2.8", + "rimraf": "2.6.2", + "semver": "5.5.0", + "tar": "4.4.1" + } + }, + "nopt": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz", + "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=", + "dev": true, + "optional": true, + "requires": { + "abbrev": "1.1.1", + "osenv": "0.1.5" + } + }, + "npm-bundled": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-1.0.3.tgz", + "integrity": "sha512-ByQ3oJ/5ETLyglU2+8dBObvhfWXX8dtPZDMePCahptliFX2iIuhyEszyFk401PZUNQH20vvdW5MLjJxkwU80Ow==", + "dev": true, + "optional": true + }, + "npm-packlist": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-1.1.10.tgz", + "integrity": "sha512-AQC0Dyhzn4EiYEfIUjCdMl0JJ61I2ER9ukf/sLxJUcZHfo+VyEfz2rMJgLZSS1v30OxPQe1cN0LZA1xbcaVfWA==", + "dev": true, + "optional": true, + "requires": { + "ignore-walk": "3.0.1", + "npm-bundled": "1.0.3" + } + }, + "npmlog": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz", + "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==", + "dev": true, + "optional": true, + "requires": { + "are-we-there-yet": "1.1.4", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.0" + } + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", + "dev": true + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", + "dev": true, + "optional": true + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "dev": true, + "requires": { + "wrappy": "1.0.2" + } + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=", + "dev": true, + "optional": true + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", + "dev": true, + "optional": true + }, + "osenv": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz", + "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==", + "dev": true, + "optional": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", + "dev": true, + "optional": true + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==", + "dev": true, + "optional": true + }, + "rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dev": true, + "optional": true, + "requires": { + "deep-extend": "0.6.0", + "ini": "1.3.5", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true, + "optional": true + } + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "dev": true, + "optional": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "dev": true, + "optional": true, + "requires": { + "glob": "7.1.2" + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==", + "dev": true + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true, + "optional": true + }, + "sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==", + "dev": true, + "optional": true + }, + "semver": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", + "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==", + "dev": true, + "optional": true + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", + "dev": true, + "optional": true + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "dev": true, + "optional": true + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "dev": true, + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "optional": true, + "requires": { + "safe-buffer": "5.1.1" + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "dev": true, + "requires": { + "ansi-regex": "2.1.1" + } + }, + "tar": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-4.4.1.tgz", + "integrity": "sha512-O+v1r9yN4tOsvl90p5HAP4AEqbYhx4036AGMm075fH9F8Qwi3oJ+v4u50FkT/KkvywNGtwkk0zRI+8eYm1X/xg==", + "dev": true, + "optional": true, + "requires": { + "chownr": "1.0.1", + "fs-minipass": "1.2.5", + "minipass": "2.2.4", + "minizlib": "1.1.0", + "mkdirp": "0.5.1", + "safe-buffer": "5.1.1", + "yallist": "3.0.2" + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", + "dev": true, + "optional": true + }, + "wide-align": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.2.tgz", + "integrity": "sha512-ijDLlyQ7s6x1JgCLur53osjm/UXUYD9+0PbYKrBsYisYXzCxN+HC3mYDNy/dWdmf3AwqwU3CXwDCvsNgGK1S0w==", + "dev": true, + "optional": true, + "requires": { + "string-width": "1.0.2" + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", + "dev": true + }, + "yallist": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.0.2.tgz", + "integrity": "sha1-hFK0u36Dx8GI2AQcGoN8dz1ti7k=", + "dev": true + } + } + }, + "ftp": { + "version": "0.3.10", + "resolved": "https://registry.npmjs.org/ftp/-/ftp-0.3.10.tgz", + "integrity": "sha1-kZfYYa2BQvPmPVqDv+TFn3MwiF0=", + "requires": { + "readable-stream": "1.1.14", + "xregexp": "2.0.0" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", + "dev": true + }, + "gauge": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", + "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", + "requires": { + "aproba": "1.2.0", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.2" + } + }, + "gaze": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/gaze/-/gaze-1.1.3.tgz", + "integrity": "sha512-BRdNm8hbWzFzWHERTrejLqwHDfS4GibPoq5wjTPIoJHoBtKGPg3xAFfxmM+9ztbXelxcf2hwQcaz1PtmFeue8g==", + "dev": true, + "requires": { + "globule": "1.2.0" + } + }, + "get-mongodb-version": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-mongodb-version/-/get-mongodb-version-1.0.0.tgz", + "integrity": "sha1-pSTTu1Ph6Ff84Jt0DSQB5HVWKqM=", + "dev": true, + "requires": { + "debug": "2.6.9", + "lodash.startswith": "4.2.1", + "minimist": "1.2.0", + "mongodb": "2.2.35", + "which": "1.3.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "es6-promise": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-3.2.1.tgz", + "integrity": "sha1-7FYjOGgDKQkgcXDDlEjiREndH8Q=", + "dev": true + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + }, + "mongodb": { + "version": "2.2.35", + "resolved": "https://registry.npmjs.org/mongodb/-/mongodb-2.2.35.tgz", + "integrity": "sha1-zRta+KlGPj+aeH+ls9BVZVeXMPk=", + "dev": true, + "requires": { + "es6-promise": "3.2.1", + "mongodb-core": "2.1.19", + "readable-stream": "2.2.7" + } + }, + "mongodb-core": { + "version": "2.1.19", + "resolved": "https://registry.npmjs.org/mongodb-core/-/mongodb-core-2.1.19.tgz", + "integrity": "sha1-APvV5aNXN2O5Fxz9hE5gqPKjoYs=", + "dev": true, + "requires": { + "bson": "1.0.6", + "require_optional": "1.0.1" + } + }, + "process-nextick-args": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz", + "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=", + "dev": true + }, + "readable-stream": { + "version": "2.2.7", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.2.7.tgz", + "integrity": "sha1-BwV6y+JGeyIELTb5jFrVBwVOlbE=", + "dev": true, + "requires": { + "buffer-shims": "1.0.0", + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.2" + } + } + } + }, + "get-proxy": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/get-proxy/-/get-proxy-2.1.0.tgz", + "integrity": "sha512-zmZIaQTWnNQb4R4fJUEp/FC51eZsc6EkErspy3xtIYStaq8EB/hDIWipxsal+E8rz0qD7f2sL/NA9Xee4RInJw==", + "dev": true, + "requires": { + "npm-conf": "1.1.3" + } + }, + "get-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=", + "dev": true + }, + "get-uri": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-2.0.1.tgz", + "integrity": "sha1-29ysrNjGCKODFoaTaBF2l6FjHFk=", + "requires": { + "data-uri-to-buffer": "1.2.0", + "debug": "2.6.9", + "extend": "3.0.1", + "file-uri-to-path": "1.0.0", + "ftp": "0.3.10", + "readable-stream": "2.3.6" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha1-XRKFFd8TT/Mn6QpMk/Tgd6U2NB8=", + "requires": { + "ms": "2.0.0" + } + } + } + }, + "get-value": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", + "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", + "dev": true + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "requires": { + "assert-plus": "1.0.0" + } + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "glob-base": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz", + "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=", + "dev": true, + "optional": true, + "requires": { + "glob-parent": "2.0.0", + "is-glob": "2.0.1" + } + }, + "glob-parent": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz", + "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=", + "dev": true, + "requires": { + "is-glob": "2.0.1" + } + }, + "global-dirs": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-0.1.1.tgz", + "integrity": "sha1-sxnA3UYH81PzvpzKTHL8FIxJ9EU=", + "dev": true, + "requires": { + "ini": "1.3.5" + } + }, + "globals": { + "version": "9.18.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz", + "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==", + "dev": true + }, + "globby": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-5.0.0.tgz", + "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=", + "dev": true, + "requires": { + "array-union": "1.0.2", + "arrify": "1.0.1", + "glob": "7.1.2", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" + } + }, + "globule": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/globule/-/globule-1.2.0.tgz", + "integrity": "sha1-HcScaCLdnoovoAuiopUAboZkvQk=", + "dev": true, + "requires": { + "glob": "7.1.2", + "lodash": "4.17.5", + "minimatch": "3.0.4" + } + }, + "got": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/got/-/got-7.1.0.tgz", + "integrity": "sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==", + "dev": true, + "requires": { + "decompress-response": "3.3.0", + "duplexer3": "0.1.4", + "get-stream": "3.0.0", + "is-plain-obj": "1.1.0", + "is-retry-allowed": "1.1.0", + "is-stream": "1.1.0", + "isurl": "1.0.0", + "lowercase-keys": "1.0.1", + "p-cancelable": "0.3.0", + "p-timeout": "1.2.1", + "safe-buffer": "5.1.2", + "timed-out": "4.0.1", + "url-parse-lax": "1.0.0", + "url-to-options": "1.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + }, + "graceful-readlink": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz", + "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=", + "dev": true + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" + }, + "har-validator": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.0.3.tgz", + "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", + "requires": { + "ajv": "5.5.2", + "har-schema": "2.0.0" + } + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "requires": { + "function-bind": "1.1.1" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "dev": true, + "requires": { + "ansi-regex": "2.1.1" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "has-symbol-support-x": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz", + "integrity": "sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==", + "dev": true + }, + "has-symbols": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz", + "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=", + "dev": true + }, + "has-to-string-tag-x": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz", + "integrity": "sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==", + "dev": true, + "requires": { + "has-symbol-support-x": "1.4.2" + } + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=" + }, + "has-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", + "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", + "dev": true, + "requires": { + "get-value": "2.0.6", + "has-values": "1.0.0", + "isobject": "3.0.1" + }, + "dependencies": { + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "has-values": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", + "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", + "dev": true, + "requires": { + "is-number": "3.0.0", + "kind-of": "4.0.0" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "kind-of": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "hawk": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/hawk/-/hawk-6.0.2.tgz", + "integrity": "sha512-miowhl2+U7Qle4vdLqDdPt9m09K6yZhkLDTWGoUiUzrQCn+mHHSmfJgAyGaLRZbPmTqfFFjRV1QWCW0VWUJBbQ==", + "requires": { + "boom": "4.3.1", + "cryptiles": "3.1.2", + "hoek": "4.2.1", + "sntp": "2.1.0" + } + }, + "hoek": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/hoek/-/hoek-4.2.1.tgz", + "integrity": "sha512-QLg82fGkfnJ/4iy1xZ81/9SIJiq1NGFUMGs6ParyjBZr6jW2Ufj/snDqTHixNlHdPNwN2RLVD0Pi3igeK9+JfA==" + }, + "home-or-tmp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz", + "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=", + "dev": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "htmlparser2": { + "version": "3.9.2", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.9.2.tgz", + "integrity": "sha1-G9+HrMoPP55T+k/M6w9LTLsAszg=", + "dev": true, + "requires": { + "domelementtype": "1.3.0", + "domhandler": "2.4.2", + "domutils": "1.5.1", + "entities": "1.1.1", + "inherits": "2.0.3", + "readable-stream": "2.3.6" + } + }, + "http-errors": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", + "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", + "requires": { + "depd": "1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.0", + "statuses": "1.5.0" + } + }, + "http-proxy-agent": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-2.1.0.tgz", + "integrity": "sha1-5IIb7vWyFCogJr1zkm/lN2McVAU=", + "requires": { + "agent-base": "4.2.0", + "debug": "3.1.0" + } + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "requires": { + "assert-plus": "1.0.0", + "jsprim": "1.4.1", + "sshpk": "1.14.1" + } + }, + "https-proxy-agent": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.1.tgz", + "integrity": "sha1-UVUpcPoE1yPgTFbQQXjD+SWSu8A=", + "requires": { + "agent-base": "4.2.0", + "debug": "3.1.0" + } + }, + "iconv-lite": { + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.23.tgz", + "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==", + "requires": { + "safer-buffer": "2.1.2" + } + }, + "ieee754": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.8.tgz", + "integrity": "sha1-vjPUCsEO8ZJnAfbwii2G+/0a0+Q=" + }, + "ignore": { + "version": "3.3.10", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.10.tgz", + "integrity": "sha512-Pgs951kaMm5GXP7MOvxERINe3gsaVjUWFm+UZPSq9xYriQAksyhg0csnS0KXSNRD5NmNdapXEpjxG49+AKh/ug==", + "dev": true + }, + "ignore-by-default": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz", + "integrity": "sha1-SMptcvbGo68Aqa1K5odr44ieKwk=", + "dev": true + }, + "import-lazy": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-2.1.0.tgz", + "integrity": "sha1-BWmOPUXIjo1+nZLLBYTnfwlvPkM=", + "dev": true + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "dev": true + }, + "indent-string": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-3.2.0.tgz", + "integrity": "sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=", + "dev": true + }, + "inflection": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/inflection/-/inflection-1.12.0.tgz", + "integrity": "sha1-ogCTVlbW9fa8TcdQLhrstwMihBY=" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "ini": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz", + "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==", + "dev": true + }, + "inquirer": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-5.2.0.tgz", + "integrity": "sha512-E9BmnJbAKLPGonz0HeWHtbKf+EeSP93paWO3ZYoUpq/aowXvYGjjCSuashhXPpzbArIjBbji39THkxTz9ZeEUQ==", + "dev": true, + "requires": { + "ansi-escapes": "3.1.0", + "chalk": "2.4.1", + "cli-cursor": "2.1.0", + "cli-width": "2.2.0", + "external-editor": "2.2.0", + "figures": "2.0.0", + "lodash": "4.17.5", + "mute-stream": "0.0.7", + "run-async": "2.3.0", + "rxjs": "5.5.11", + "string-width": "2.1.1", + "strip-ansi": "4.0.0", + "through": "2.3.8" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha1-q5Pyeo3BPSjKyBXEYhQ6bZASrp4=", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "dev": true, + "requires": { + "has-flag": "3.0.0" + } + } + } + }, + "intersect": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/intersect/-/intersect-1.0.1.tgz", + "integrity": "sha1-MyZQ4QhU2MCsWMGSvcJ6i/fnoww=" + }, + "invariant": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", + "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==", + "dev": true, + "requires": { + "loose-envify": "1.3.1" + } + }, + "ip": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/ip/-/ip-1.1.5.tgz", + "integrity": "sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo=" + }, + "ipaddr.js": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.6.0.tgz", + "integrity": "sha1-4/o1e3c9phnybpXwSdBVxyeW+Gs=" + }, + "is-accessor-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", + "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-binary-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", + "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", + "dev": true, + "requires": { + "binary-extensions": "1.11.0" + } + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", + "dev": true + }, + "is-callable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz", + "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=", + "dev": true + }, + "is-ci": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-1.1.0.tgz", + "integrity": "sha512-c7TnwxLePuqIlxHgr7xtxzycJPegNHFuIrBkwbf8hc58//+Op1CqFkyS+xnIMkwn9UsJIwc174BIjkyBmSpjKg==", + "dev": true, + "requires": { + "ci-info": "1.1.3" + } + }, + "is-data-descriptor": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", + "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=", + "dev": true + }, + "is-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", + "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "0.1.6", + "is-data-descriptor": "0.1.4", + "kind-of": "5.1.0" + }, + "dependencies": { + "kind-of": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", + "dev": true + } + } + }, + "is-dotfile": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz", + "integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=", + "dev": true, + "optional": true + }, + "is-equal-shallow": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz", + "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=", + "dev": true, + "optional": true, + "requires": { + "is-primitive": "2.0.0" + } + }, + "is-extendable": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", + "dev": true + }, + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-finite": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz", + "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "requires": { + "number-is-nan": "1.0.1" + } + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + }, + "is-installed-globally": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.1.0.tgz", + "integrity": "sha1-Df2Y9akRFxbdU13aZJL2e/PSWoA=", + "dev": true, + "requires": { + "global-dirs": "0.1.1", + "is-path-inside": "1.0.1" + } + }, + "is-mongodb-running": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/is-mongodb-running/-/is-mongodb-running-0.0.1.tgz", + "integrity": "sha1-7QdQhQ3uaj6X50ZX+6nm+jvTEmI=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "debug": "2.6.9", + "figures": "1.7.0", + "lodash": "3.10.1", + "lsof": "0.1.0", + "minimist": "1.2.0", + "ps-node": "0.0.5" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "figures": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz", + "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5", + "object-assign": "4.1.1" + } + }, + "lodash": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz", + "integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=", + "dev": true + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + } + } + }, + "is-natural-number": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/is-natural-number/-/is-natural-number-4.0.1.tgz", + "integrity": "sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=", + "dev": true + }, + "is-npm": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-1.0.0.tgz", + "integrity": "sha1-8vtjpl5JBbQGyGBydloaTceTufQ=", + "dev": true + }, + "is-number": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz", + "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=", + "dev": true, + "optional": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha1-PkcprB9f3gJc19g6iW2rn09n2w8=", + "dev": true + }, + "is-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz", + "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=", + "dev": true + }, + "is-odd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-odd/-/is-odd-2.0.0.tgz", + "integrity": "sha1-dkZiRnH9fqVYzNmieVGC8pWPGyQ=", + "dev": true, + "requires": { + "is-number": "4.0.0" + }, + "dependencies": { + "is-number": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", + "integrity": "sha1-ACbjf1RU1z41bf5lZGmYZ8an8P8=", + "dev": true + } + } + }, + "is-path-cwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz", + "integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=", + "dev": true + }, + "is-path-in-cwd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz", + "integrity": "sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==", + "dev": true, + "requires": { + "is-path-inside": "1.0.1" + } + }, + "is-path-inside": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.1.tgz", + "integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=", + "dev": true, + "requires": { + "path-is-inside": "1.0.2" + } + }, + "is-plain-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", + "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=", + "dev": true + }, + "is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "dev": true, + "requires": { + "isobject": "3.0.1" + }, + "dependencies": { + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "is-posix-bracket": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz", + "integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=", + "dev": true, + "optional": true + }, + "is-primitive": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz", + "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=", + "dev": true, + "optional": true + }, + "is-promise": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz", + "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=", + "dev": true + }, + "is-redirect": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-redirect/-/is-redirect-1.0.0.tgz", + "integrity": "sha1-HQPd7VO9jbDzDCbk+V02/HyH3CQ=", + "dev": true + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "dev": true, + "requires": { + "has": "1.0.3" + } + }, + "is-resolvable": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.1.0.tgz", + "integrity": "sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==", + "dev": true + }, + "is-retry-allowed": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz", + "integrity": "sha1-EaBgVotnM5REAz0BJaYaINVk+zQ=", + "dev": true + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "is-symbol": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz", + "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=", + "dev": true + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "is-windows": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", + "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", + "dev": true + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", + "dev": true + }, + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "dev": true, + "optional": true, + "requires": { + "isarray": "1.0.0" + } + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "istanbul-lib-coverage": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-1.2.0.tgz", + "integrity": "sha512-GvgM/uXRwm+gLlvkWHTjDAvwynZkL9ns15calTrmhGgowlwJBbWMYzWbKqE2DT6JDP1AFXKa+Zi0EkqNCUqY0A==", + "dev": true + }, + "istanbul-lib-instrument": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-2.1.0.tgz", + "integrity": "sha512-3ly7GAJiPKqgbGKh2s01ysk3jd/egpE1i84PYu3BvPkssqrKMXZY9KRGX0mfZ+cmCfTR1IFVnnn/tDHxTer4nA==", + "dev": true, + "requires": { + "@babel/generator": "7.0.0-beta.49", + "@babel/parser": "7.0.0-beta.49", + "@babel/template": "7.0.0-beta.49", + "@babel/traverse": "7.0.0-beta.49", + "@babel/types": "7.0.0-beta.49", + "istanbul-lib-coverage": "1.2.0", + "semver": "5.5.0" + }, + "dependencies": { + "@babel/code-frame": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0-beta.49.tgz", + "integrity": "sha1-vs2AVIJzREDJ0TfkbXc0DmTX9Rs=", + "dev": true, + "requires": { + "@babel/highlight": "7.0.0-beta.49" + } + }, + "@babel/generator": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.0.0-beta.49.tgz", + "integrity": "sha1-6c/9qROZaszseTu8JauRvBnQv3o=", + "dev": true, + "requires": { + "@babel/types": "7.0.0-beta.49", + "jsesc": "2.5.1", + "lodash": "4.17.5", + "source-map": "0.5.7", + "trim-right": "1.0.1" + } + }, + "@babel/helper-function-name": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.0.0-beta.49.tgz", + "integrity": "sha1-olwRGbnwNSeGcBJuAiXAMEHI3jI=", + "dev": true, + "requires": { + "@babel/helper-get-function-arity": "7.0.0-beta.49", + "@babel/template": "7.0.0-beta.49", + "@babel/types": "7.0.0-beta.49" + } + }, + "@babel/helper-get-function-arity": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0-beta.49.tgz", + "integrity": "sha1-z1Aj8y0q2S0Ic3STnOwJUby1FEE=", + "dev": true, + "requires": { + "@babel/types": "7.0.0-beta.49" + } + }, + "@babel/helper-split-export-declaration": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0-beta.49.tgz", + "integrity": "sha1-QNeO2glo0BGxxShm5XRs+yPldUg=", + "dev": true, + "requires": { + "@babel/types": "7.0.0-beta.49" + } + }, + "@babel/highlight": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0-beta.49.tgz", + "integrity": "sha1-lr3GtD4TSCASumaRsQGEktOWIsw=", + "dev": true, + "requires": { + "chalk": "2.4.1", + "esutils": "2.0.2", + "js-tokens": "3.0.2" + } + }, + "@babel/template": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.0.0-beta.49.tgz", + "integrity": "sha1-44q+ghfLl5P0YaUwbXrXRdg+HSc=", + "dev": true, + "requires": { + "@babel/code-frame": "7.0.0-beta.49", + "@babel/parser": "7.0.0-beta.49", + "@babel/types": "7.0.0-beta.49", + "lodash": "4.17.5" + } + }, + "@babel/traverse": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.0.0-beta.49.tgz", + "integrity": "sha1-TypzaCoYM07WYl0QCo0nMZ98LWg=", + "dev": true, + "requires": { + "@babel/code-frame": "7.0.0-beta.49", + "@babel/generator": "7.0.0-beta.49", + "@babel/helper-function-name": "7.0.0-beta.49", + "@babel/helper-split-export-declaration": "7.0.0-beta.49", + "@babel/parser": "7.0.0-beta.49", + "@babel/types": "7.0.0-beta.49", + "debug": "3.1.0", + "globals": "11.5.0", + "invariant": "2.2.4", + "lodash": "4.17.5" + } + }, + "@babel/types": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.0.0-beta.49.tgz", + "integrity": "sha1-t+Oxw/TUz+Eb34yJ8e/V4WF7h6Y=", + "dev": true, + "requires": { + "esutils": "2.0.2", + "lodash": "4.17.5", + "to-fast-properties": "2.0.0" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "globals": { + "version": "11.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.5.0.tgz", + "integrity": "sha512-hYyf+kI8dm3nORsiiXUQigOU62hDLfJ9G01uyGMxhc6BKsircrUhC4uJPQPUSuq2GrTmiiEt7ewxlMdBewfmKQ==", + "dev": true + }, + "jsesc": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.1.tgz", + "integrity": "sha1-5CGiqOINawgZ3yiQj3glJrlt0f4=", + "dev": true + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "dev": true, + "requires": { + "has-flag": "3.0.0" + } + }, + "to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=", + "dev": true + } + } + }, + "isurl": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isurl/-/isurl-1.0.0.tgz", + "integrity": "sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==", + "dev": true, + "requires": { + "has-to-string-tag-x": "1.4.1", + "is-object": "1.0.1" + } + }, + "jasmine": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jasmine/-/jasmine-3.1.0.tgz", + "integrity": "sha1-K9Wf1+xuwOistk4J9Fpo7SrRlSo=", + "dev": true, + "requires": { + "glob": "7.1.2", + "jasmine-core": "3.1.0" + } + }, + "jasmine-core": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jasmine-core/-/jasmine-core-3.1.0.tgz", + "integrity": "sha1-pHheE11d9lAk38kiSVPfWFvSdmw=", + "dev": true + }, + "jasmine-spec-reporter": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/jasmine-spec-reporter/-/jasmine-spec-reporter-4.2.1.tgz", + "integrity": "sha512-FZBoZu7VE5nR7Nilzy+Np8KuVIOxF4oXDPDknehCYBDE080EnlPu0afdZNmpGDBRCUBv3mj5qgqCRmk6W/K8vg==", + "dev": true, + "requires": { + "colors": "1.1.2" + }, + "dependencies": { + "colors": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.1.2.tgz", + "integrity": "sha1-FopHAXVran9RoSzgyXv6KMCE7WM=", + "dev": true + } + } + }, + "jmespath": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/jmespath/-/jmespath-0.15.0.tgz", + "integrity": "sha1-o/Iiqarp+Wb10nx5ZRDigJF2Qhc=" + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", + "dev": true + }, + "js-yaml": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz", + "integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==", + "dev": true, + "requires": { + "argparse": "1.0.10", + "esprima": "4.0.0" + }, + "dependencies": { + "esprima": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz", + "integrity": "sha1-RJnt3NERDgshi6zy+n9/WfVcqAQ=", + "dev": true + } + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "optional": true + }, + "jsesc": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz", + "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=", + "dev": true + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", + "dev": true + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "json5": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", + "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=", + "dev": true + }, + "jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11" + } + }, + "jsonwebtoken": { + "version": "8.2.1", + "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-8.2.1.tgz", + "integrity": "sha1-Mz7jmqjyOPMvpBaT56L7fkL4KzE=", + "requires": { + "jws": "3.1.5", + "lodash.includes": "4.3.0", + "lodash.isboolean": "3.0.3", + "lodash.isinteger": "4.0.4", + "lodash.isnumber": "3.0.3", + "lodash.isplainobject": "4.0.6", + "lodash.isstring": "4.0.1", + "lodash.once": "4.1.1", + "ms": "2.1.1", + "xtend": "4.0.1" + }, + "dependencies": { + "ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha1-MKWGTrPrsKZvLr5tcnrwagnYbgo=" + } + } + }, + "jsprim": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", + "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.2.3", + "verror": "1.10.0" + } + }, + "jwa": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.1.6.tgz", + "integrity": "sha512-tBO/cf++BUsJkYql/kBbJroKOgHWEigTKBAjjBEmrMGYd1QMBC74Hr4Wo2zCZw6ZrVhlJPvoMrkcOnlWR/DJfw==", + "requires": { + "buffer-equal-constant-time": "1.0.1", + "ecdsa-sig-formatter": "1.0.10", + "safe-buffer": "5.1.2" + } + }, + "jws": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/jws/-/jws-3.1.5.tgz", + "integrity": "sha512-GsCSexFADNQUr8T5HPJvayTjvPIfoyJPtLQBwn5a4WZQchcrPMPMAWcC1AzJVRDKyD6ZPROPAxgv6rfHViO4uQ==", + "requires": { + "jwa": "1.1.6", + "safe-buffer": "5.1.2" + } + }, + "key-tree-store": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/key-tree-store/-/key-tree-store-1.3.0.tgz", + "integrity": "sha1-XqKa/CUppCWThDfWlVtxTOapeR8=", + "dev": true + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + }, + "klaw": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", + "integrity": "sha1-QIhDO0azsbolnXh4XY6W9zugJDk=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11" + } + }, + "latest-version": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-3.1.0.tgz", + "integrity": "sha1-ogU4P+oyKzO1rjsYq+4NwvNW7hU=", + "dev": true, + "requires": { + "package-json": "4.0.1" + } + }, + "lazystream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.0.tgz", + "integrity": "sha1-9plf4PggOS9hOWvolGJAe7dxaOQ=", + "requires": { + "readable-stream": "2.3.6" + } + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "requires": { + "prelude-ls": "1.1.2", + "type-check": "0.3.2" + } + }, + "limiter": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/limiter/-/limiter-1.1.3.tgz", + "integrity": "sha512-zrycnIMsLw/3ZxTbW7HCez56rcFGecWTx5OZNplzcXUUmJLmoYArC6qdJzmAN5BWiNXGcpjhF9RQ1HSv5zebEw==", + "dev": true + }, + "lodash": { + "version": "4.17.5", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.5.tgz", + "integrity": "sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==" + }, + "lodash.assignin": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assignin/-/lodash.assignin-4.2.0.tgz", + "integrity": "sha1-uo31+4QesKPoBEIysOJjqNxqKKI=", + "dev": true + }, + "lodash.bind": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/lodash.bind/-/lodash.bind-4.2.1.tgz", + "integrity": "sha1-euMBfpOWIqwxt9fX3LGzTbFpDTU=", + "dev": true + }, + "lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha1-gteb/zCmfEAF/9XiUVMArZyk168=", + "dev": true + }, + "lodash.defaults": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz", + "integrity": "sha1-0JF4cW/+pN3p5ft7N/bwgCJ0WAw=", + "dev": true + }, + "lodash.difference": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz", + "integrity": "sha1-nMtOUF1Ia5FlE0V3KIWi3yf9AXw=", + "dev": true + }, + "lodash.filter": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.filter/-/lodash.filter-4.6.0.tgz", + "integrity": "sha1-ZosdSYFgOuHMWm+nYBQ+SAtMSs4=", + "dev": true + }, + "lodash.flatten": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz", + "integrity": "sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=", + "dev": true + }, + "lodash.foreach": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.foreach/-/lodash.foreach-4.5.0.tgz", + "integrity": "sha1-Gmo16s5AEoDH8G3d7DUWWrJ+PlM=", + "dev": true + }, + "lodash.includes": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz", + "integrity": "sha1-YLuYqHy5I8aMoeUTJUgzFISfVT8=" + }, + "lodash.isboolean": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz", + "integrity": "sha1-bC4XHbKiV82WgC/UOwGyDV9YcPY=" + }, + "lodash.isinteger": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz", + "integrity": "sha1-YZwK89A/iwTDH1iChAt3sRzWg0M=" + }, + "lodash.isnumber": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz", + "integrity": "sha1-POdoEMWSjQM1IwGsKHMX8RwLH/w=" + }, + "lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=" + }, + "lodash.isstring": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz", + "integrity": "sha1-1SfftUVuynzJu5XV2ur4i6VKVFE=" + }, + "lodash.map": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.map/-/lodash.map-4.6.0.tgz", + "integrity": "sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=", + "dev": true + }, + "lodash.merge": { + "version": "4.6.1", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.1.tgz", + "integrity": "sha512-AOYza4+Hf5z1/0Hztxpm2/xiPZgi/cjMqdnKTUWTBSKchJlxXXuUSxCCl8rJlf4g6yww/j6mA8nC8Hw/EZWxKQ==", + "dev": true + }, + "lodash.once": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz", + "integrity": "sha1-DdOXEhPHxW34gJd9UEyI+0cal6w=" + }, + "lodash.pad": { + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/lodash.pad/-/lodash.pad-4.5.1.tgz", + "integrity": "sha1-QzCUmoM6fI2iLMIPaibE1Z3runA=", + "dev": true + }, + "lodash.padend": { + "version": "4.6.1", + "resolved": "https://registry.npmjs.org/lodash.padend/-/lodash.padend-4.6.1.tgz", + "integrity": "sha1-U8y6BH0G4VjTEfRdpiX05J5vFm4=", + "dev": true + }, + "lodash.padstart": { + "version": "4.6.1", + "resolved": "https://registry.npmjs.org/lodash.padstart/-/lodash.padstart-4.6.1.tgz", + "integrity": "sha1-0uPuv/DZ05rVD1y9G1KnvOa7YRs=", + "dev": true + }, + "lodash.pick": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.pick/-/lodash.pick-4.4.0.tgz", + "integrity": "sha1-UvBWEP/53tQiYRRB7R/BI6AwAbM=", + "dev": true + }, + "lodash.reduce": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.reduce/-/lodash.reduce-4.6.0.tgz", + "integrity": "sha1-8atrg5KZrUj3hKu/R2WW8DuRTTs=", + "dev": true + }, + "lodash.reject": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.reject/-/lodash.reject-4.6.0.tgz", + "integrity": "sha1-gNZJLcFHCGS79YNTO2UfQqn1JBU=", + "dev": true + }, + "lodash.some": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.some/-/lodash.some-4.6.0.tgz", + "integrity": "sha1-G7nzFO9ri63tE7VJFpsqlF62jk0=", + "dev": true + }, + "lodash.startswith": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/lodash.startswith/-/lodash.startswith-4.2.1.tgz", + "integrity": "sha1-xZjErc4YiiflMUVzHNxsDnF3YAw=", + "dev": true + }, + "loose-envify": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.3.1.tgz", + "integrity": "sha1-0aitM/qc4OcT1l/dCsi3SNR4yEg=", + "dev": true, + "requires": { + "js-tokens": "3.0.2" + } + }, + "lowercase-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz", + "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==", + "dev": true + }, + "lru-cache": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.2.tgz", + "integrity": "sha512-wgeVXhrDwAWnIF/yZARsFnMBtdFXOg1b8RIrhilp+0iDYN4mdQcNZElDZ0e4B64BhaxeQ5zN7PMyvu7we1kPeQ==", + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + } + }, + "lru-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/lru-queue/-/lru-queue-0.1.0.tgz", + "integrity": "sha1-Jzi9nw089PhEkMVzbEhpmsYyzaM=", + "dev": true, + "requires": { + "es5-ext": "0.10.45" + } + }, + "lsof": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/lsof/-/lsof-0.1.0.tgz", + "integrity": "sha1-rALU2HYGIB8TZLr7FcSRz9WuMJI=", + "dev": true + }, + "mailgun-js": { + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/mailgun-js/-/mailgun-js-0.18.0.tgz", + "integrity": "sha1-gf7QxmpBHT/2xDVIYa0hOHr8+qo=", + "requires": { + "async": "2.6.0", + "debug": "3.1.0", + "form-data": "2.3.2", + "inflection": "1.12.0", + "is-stream": "1.1.0", + "path-proxy": "1.0.0", + "promisify-call": "2.0.4", + "proxy-agent": "3.0.0", + "tsscmp": "1.0.5" + } + }, + "make-dir": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.2.0.tgz", + "integrity": "sha1-bWpJ7q1KrilsU7vzoaAIvWyJRps=", + "dev": true, + "requires": { + "pify": "3.0.0" + }, + "dependencies": { + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", + "dev": true + } + } + }, + "manakin": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/manakin/-/manakin-0.5.1.tgz", + "integrity": "sha1-xKcRb2sA3z1fGjetPKUV0iBlplg=" + }, + "map-cache": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", + "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", + "dev": true + }, + "map-stream": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.1.0.tgz", + "integrity": "sha1-5WqpTEyAVaFkBKBnS3jyFffI4ZQ=", + "dev": true + }, + "map-visit": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", + "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", + "dev": true, + "requires": { + "object-visit": "1.0.1" + } + }, + "math-random": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/math-random/-/math-random-1.0.1.tgz", + "integrity": "sha1-izqsWIuKZuSXXjzepn97sylgH6w=", + "dev": true, + "optional": true + }, + "media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=" + }, + "memoizee": { + "version": "0.3.10", + "resolved": "https://registry.npmjs.org/memoizee/-/memoizee-0.3.10.tgz", + "integrity": "sha1-TsoNiu057J0Bf0xcLy9kMvQuXI8=", + "dev": true, + "requires": { + "d": "0.1.1", + "es5-ext": "0.10.45", + "es6-weak-map": "0.1.4", + "event-emitter": "0.3.5", + "lru-queue": "0.1.0", + "next-tick": "0.2.2", + "timers-ext": "0.1.5" + }, + "dependencies": { + "next-tick": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-0.2.2.tgz", + "integrity": "sha1-ddpKkn7liH45BliABltzNkE7MQ0=", + "dev": true + } + } + }, + "merge-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", + "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E=" + }, + "methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=" + }, + "micromatch": { + "version": "2.3.11", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz", + "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=", + "dev": true, + "optional": true, + "requires": { + "arr-diff": "2.0.0", + "array-unique": "0.2.1", + "braces": "1.8.5", + "expand-brackets": "0.1.5", + "extglob": "0.3.2", + "filename-regex": "2.0.1", + "is-extglob": "1.0.0", + "is-glob": "2.0.1", + "kind-of": "3.2.2", + "normalize-path": "2.1.1", + "object.omit": "2.0.1", + "parse-glob": "3.0.4", + "regex-cache": "0.4.4" + } + }, + "mime": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/mime/-/mime-2.3.1.tgz", + "integrity": "sha1-sWIcVNY7l8R9PP5/chX31kUXw2k=" + }, + "mime-db": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.33.0.tgz", + "integrity": "sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ==" + }, + "mime-types": { + "version": "2.1.18", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.18.tgz", + "integrity": "sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==", + "requires": { + "mime-db": "1.33.0" + } + }, + "mimic-fn": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz", + "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==", + "dev": true + }, + "mimic-response": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.0.tgz", + "integrity": "sha1-3z02Uqc/3ta5sLJBRub9BSNTRY4=", + "dev": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.11" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "mixin-deep": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.1.tgz", + "integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==", + "dev": true, + "requires": { + "for-in": "1.0.2", + "is-extendable": "1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", + "dev": true, + "requires": { + "is-plain-object": "2.0.4" + } + } + } + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + } + }, + "mongodb": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/mongodb/-/mongodb-3.1.1.tgz", + "integrity": "sha512-GU9oWK4pi8PC7NyGiwjFMwZyMqwGWoMEMvM0LZh7UKW/FFAqgmZKjjriD+5MEOCDUJE2dtHX93/K5UtDxO0otg==", + "requires": { + "mongodb-core": "3.1.0" + } + }, + "mongodb-core": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mongodb-core/-/mongodb-core-3.1.0.tgz", + "integrity": "sha512-qRjG62Fu//CZhkgn0jA/k8jh5MhACIq8cOJUryH6sck87pgt+C222MSD02tsCq5zNo/B6ZFHtNodZ2qpf8E86g==", + "requires": { + "bson": "1.0.6", + "require_optional": "1.0.1", + "saslprep": "1.0.0" + } + }, + "mongodb-dbpath": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/mongodb-dbpath/-/mongodb-dbpath-0.0.1.tgz", + "integrity": "sha1-4BMsZ3sbncgwBFEW0Yrbf2kk8XU=", + "dev": true, + "requires": { + "async": "1.5.2", + "debug": "2.6.9", + "minimist": "1.2.0", + "mkdirp": "0.5.1", + "untildify": "1.0.0" + }, + "dependencies": { + "async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=", + "dev": true + }, + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + }, + "untildify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-1.0.0.tgz", + "integrity": "sha1-TYAx0YBvT718QrAjeq8hNoYmJjU=", + "dev": true, + "requires": { + "user-home": "1.1.1" + } + } + } + }, + "mongodb-download-url": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/mongodb-download-url/-/mongodb-download-url-0.3.3.tgz", + "integrity": "sha1-46ilSPE+sg9aDN+GPLwGNCGjk0w=", + "dev": true, + "requires": { + "async": "2.6.0", + "debug": "2.6.9", + "lodash.defaults": "4.2.0", + "minimist": "1.2.0", + "mongodb-version-list": "1.0.0", + "request": "2.85.0", + "semver": "5.5.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + } + } + }, + "mongodb-runner": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mongodb-runner/-/mongodb-runner-4.0.0.tgz", + "integrity": "sha512-ln20t36NelSvzUTvi6ywzisUNvn/UMajM0ydYEET/Gd3/jd4Pm0B8xR2tRTSnjnHvUZhGyD+3reWKnqN3C310A==", + "dev": true, + "requires": { + "async": "2.6.0", + "clui": "0.3.6", + "debug": "3.1.0", + "fs-extra": "4.0.3", + "is-mongodb-running": "0.0.1", + "lodash.defaults": "4.2.0", + "minimist": "1.2.0", + "mkdirp": "0.5.1", + "mongodb": "3.1.1", + "mongodb-dbpath": "0.0.1", + "mongodb-tools": "github:mongodb-js/mongodb-tools#df761df21175f2c521c78b8e011a1532569f0dca", + "mongodb-version-manager": "1.1.3", + "untildify": "3.0.3", + "which": "1.3.0" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + } + } + }, + "mongodb-tools": { + "version": "github:mongodb-js/mongodb-tools#df761df21175f2c521c78b8e011a1532569f0dca", + "dev": true, + "requires": { + "debug": "2.6.9", + "lodash": "3.10.1", + "mkdirp": "0.5.0", + "mongodb-core": "2.1.19", + "rimraf": "2.2.6" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "lodash": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz", + "integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=", + "dev": true + }, + "mkdirp": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.0.tgz", + "integrity": "sha1-HXMHam35hs2TROFecfzAWkyavxI=", + "dev": true, + "requires": { + "minimist": "0.0.8" + } + }, + "mongodb-core": { + "version": "2.1.19", + "resolved": "https://registry.npmjs.org/mongodb-core/-/mongodb-core-2.1.19.tgz", + "integrity": "sha512-Jt4AtWUkpuW03kRdYGxga4O65O1UHlFfvvInslEfLlGi+zDMxbBe3J2NVmN9qPJ957Mn6Iz0UpMtV80cmxCVxw==", + "dev": true, + "requires": { + "bson": "1.0.6", + "require_optional": "1.0.1" + } + }, + "rimraf": { + "version": "2.2.6", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.2.6.tgz", + "integrity": "sha1-xZWXVpsU2VatKcrMQr3d9fDqT0w=", + "dev": true + } + } + }, + "mongodb-version-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/mongodb-version-list/-/mongodb-version-list-1.0.0.tgz", + "integrity": "sha1-8lAxz83W8UWx3o/OKk6+wCiLtKQ=", + "dev": true, + "requires": { + "cheerio": "0.22.0", + "debug": "2.6.9", + "downcache": "0.0.9", + "fs-extra": "1.0.0", + "minimist": "1.2.0", + "semver": "5.5.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "fs-extra": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-1.0.0.tgz", + "integrity": "sha1-zTzl9+fLYUWIP8rjGR6Yd/hYeVA=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "jsonfile": "2.4.0", + "klaw": "1.3.1" + } + }, + "jsonfile": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", + "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + } + } + }, + "mongodb-version-manager": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/mongodb-version-manager/-/mongodb-version-manager-1.1.3.tgz", + "integrity": "sha512-EInfE8Uu4umFHnFr1+kjvxaC8n0v2HR9WEJ659FxOITStOMzzvFvKw88j4m//rK85rAKk6aZ+Kx29tRTcatrkA==", + "dev": true, + "requires": { + "ampersand-state": "5.0.3", + "async": "2.6.0", + "chalk": "2.4.1", + "debug": "3.1.0", + "docopt": "0.6.2", + "download": "6.2.5", + "figures": "2.0.0", + "fs-extra": "4.0.3", + "get-mongodb-version": "1.0.0", + "lodash.defaults": "4.2.0", + "lodash.difference": "4.5.0", + "mongodb-download-url": "0.3.3", + "mongodb-version-list": "1.0.0", + "semver": "5.5.0", + "tildify": "1.2.0", + "untildify": "3.0.3" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + } + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "multer": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/multer/-/multer-1.3.1.tgz", + "integrity": "sha512-JHdEoxkA/5NgZRo91RNn4UT+HdcJV9XUo01DTkKC7vo1erNIngtuaw9Y0WI8RdTlyi+wMIbunflhghzVLuGJyw==", + "requires": { + "append-field": "0.1.0", + "busboy": "0.2.14", + "concat-stream": "1.6.2", + "mkdirp": "0.5.1", + "object-assign": "3.0.0", + "on-finished": "2.3.0", + "type-is": "1.6.16", + "xtend": "4.0.1" + }, + "dependencies": { + "object-assign": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-3.0.0.tgz", + "integrity": "sha1-m+3VygiXlJvKR+f/QIBi1Un1h/I=" + } + } + }, + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=", + "dev": true + }, + "nan": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz", + "integrity": "sha512-bAdJv7fBLhWC+/Bls0Oza+mvTaNQtP+1RyhhhvD95pgUJz6XM5IzgmxOkItJ9tkoCiplvAnXI1tNmmUD/eScyA==", + "optional": true + }, + "nanomatch": { + "version": "1.2.9", + "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.9.tgz", + "integrity": "sha1-h59xUMstq3pHElkGbBBO7m4Pp8I=", + "dev": true, + "requires": { + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "fragment-cache": "0.2.1", + "is-odd": "2.0.0", + "is-windows": "1.0.2", + "kind-of": "6.0.2", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "arr-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", + "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", + "dev": true + }, + "array-unique": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", + "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "dev": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha1-ARRrNqYhjmTljzqNZt5df8b20FE=", + "dev": true + } + } + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", + "dev": true + }, + "negotiator": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz", + "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=" + }, + "netmask": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/netmask/-/netmask-1.0.6.tgz", + "integrity": "sha1-ICl+idhvb2QA8lDZ9Pa0wZRfzTU=" + }, + "next-tick": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz", + "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=", + "dev": true + }, + "nice-try": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.4.tgz", + "integrity": "sha512-2NpiFHqC87y/zFke0fC0spBXL3bBsoh/p5H1EFhshxjCR5+0g2d6BiXbUFz9v1sAcxsk2htp2eQnNIci2dIYcA==", + "dev": true + }, + "node-forge": { + "version": "0.7.5", + "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-0.7.5.tgz", + "integrity": "sha512-MmbQJ2MTESTjt3Gi/3yG1wGpIMhUfcIypUCGtTizFR9IiccFwxSpfp0vtIZlkFclEqERemxfnSdZEMR9VqqEFQ==" + }, + "nodemon": { + "version": "1.18.1", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-1.18.1.tgz", + "integrity": "sha512-zKKrRcn5htBkPz6N5SiFLG8kneJxhW//zO7/RB08TaQgBZrbmjUlORBy6ALIbpwwp+Q8F9mWbnbkJXh6rjlALA==", + "dev": true, + "requires": { + "chokidar": "2.0.4", + "debug": "3.1.0", + "ignore-by-default": "1.0.1", + "minimatch": "3.0.4", + "pstree.remy": "1.1.0", + "semver": "5.5.0", + "supports-color": "5.4.0", + "touch": "3.1.0", + "undefsafe": "2.0.2", + "update-notifier": "2.5.0" + }, + "dependencies": { + "anymatch": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", + "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", + "dev": true, + "requires": { + "micromatch": "3.1.10", + "normalize-path": "2.1.1" + } + }, + "arr-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", + "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", + "dev": true + }, + "array-unique": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", + "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "dev": true + }, + "braces": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "dev": true, + "requires": { + "arr-flatten": "1.1.0", + "array-unique": "0.3.2", + "extend-shallow": "2.0.1", + "fill-range": "4.0.0", + "isobject": "3.0.1", + "repeat-element": "1.1.2", + "snapdragon": "0.8.2", + "snapdragon-node": "2.1.1", + "split-string": "3.1.0", + "to-regex": "3.0.2" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "chokidar": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.0.4.tgz", + "integrity": "sha512-z9n7yt9rOvIJrMhvDtDictKrkFHeihkNl6uWMmZlmL6tJtX9Cs+87oK+teBx+JIgzvbX3yZHT3eF8vpbDxHJXQ==", + "dev": true, + "requires": { + "anymatch": "2.0.0", + "async-each": "1.0.1", + "braces": "2.3.2", + "fsevents": "1.2.3", + "glob-parent": "3.1.0", + "inherits": "2.0.3", + "is-binary-path": "1.0.1", + "is-glob": "4.0.0", + "lodash.debounce": "4.0.8", + "normalize-path": "2.1.1", + "path-is-absolute": "1.0.1", + "readdirp": "2.1.0", + "upath": "1.1.0" + } + }, + "expand-brackets": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", + "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", + "dev": true, + "requires": { + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "posix-character-classes": "0.1.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + }, + "is-accessor-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", + "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "is-data-descriptor": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", + "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "is-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", + "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "0.1.6", + "is-data-descriptor": "0.1.4", + "kind-of": "5.1.0" + } + }, + "kind-of": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", + "dev": true + } + } + }, + "extglob": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", + "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", + "dev": true, + "requires": { + "array-unique": "0.3.2", + "define-property": "1.0.0", + "expand-brackets": "2.1.4", + "extend-shallow": "2.0.1", + "fragment-cache": "0.2.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "fill-range": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-number": "3.0.0", + "repeat-string": "1.6.1", + "to-regex-range": "2.1.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "glob-parent": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", + "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=", + "dev": true, + "requires": { + "is-glob": "3.1.0", + "path-dirname": "1.0.2" + }, + "dependencies": { + "is-glob": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", + "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", + "dev": true, + "requires": { + "is-extglob": "2.1.1" + } + } + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", + "dev": true + }, + "is-glob": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.0.tgz", + "integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=", + "dev": true, + "requires": { + "is-extglob": "2.1.1" + } + }, + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true + }, + "micromatch": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", + "dev": true, + "requires": { + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "braces": "2.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "extglob": "2.0.4", + "fragment-cache": "0.2.1", + "kind-of": "6.0.2", + "nanomatch": "1.2.9", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + } + } + } + }, + "nopt": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz", + "integrity": "sha1-bd0hvSoxQXuScn3Vhfim83YI6+4=", + "dev": true, + "requires": { + "abbrev": "1.1.1" + } + }, + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "requires": { + "remove-trailing-separator": "1.1.0" + } + }, + "npm-conf": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/npm-conf/-/npm-conf-1.1.3.tgz", + "integrity": "sha512-Yic4bZHJOt9RCFbRP3GgpqhScOY4HH3V2P8yBj6CeYq118Qr+BLXqT2JvpJ00mryLESpgOxf5XlFv4ZjXxLScw==", + "dev": true, + "requires": { + "config-chain": "1.1.11", + "pify": "3.0.0" + }, + "dependencies": { + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", + "dev": true + } + } + }, + "npm-run-path": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz", + "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", + "dev": true, + "requires": { + "path-key": "2.0.1" + } + }, + "npmlog": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz", + "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==", + "requires": { + "are-we-there-yet": "1.1.4", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.0" + } + }, + "nth-check": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.1.tgz", + "integrity": "sha1-mSms32KPwsQQmN6rgqxYDPFJquQ=", + "dev": true, + "requires": { + "boolbase": "1.0.0" + } + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=" + }, + "nyc": { + "version": "12.0.2", + "resolved": "https://registry.npmjs.org/nyc/-/nyc-12.0.2.tgz", + "integrity": "sha1-ikpO1pCWbBHsWH/4fuoMEsl0upk=", + "dev": true, + "requires": { + "archy": "1.0.0", + "arrify": "1.0.1", + "caching-transform": "1.0.1", + "convert-source-map": "1.5.1", + "debug-log": "1.0.1", + "default-require-extensions": "1.0.0", + "find-cache-dir": "0.1.1", + "find-up": "2.1.0", + "foreground-child": "1.5.6", + "glob": "7.1.2", + "istanbul-lib-coverage": "1.2.0", + "istanbul-lib-hook": "1.1.0", + "istanbul-lib-instrument": "2.1.0", + "istanbul-lib-report": "1.1.3", + "istanbul-lib-source-maps": "1.2.5", + "istanbul-reports": "1.4.1", + "md5-hex": "1.3.0", + "merge-source-map": "1.1.0", + "micromatch": "3.1.10", + "mkdirp": "0.5.1", + "resolve-from": "2.0.0", + "rimraf": "2.6.2", + "signal-exit": "3.0.2", + "spawn-wrap": "1.4.2", + "test-exclude": "4.2.1", + "yargs": "11.1.0", + "yargs-parser": "8.1.0" + }, + "dependencies": { + "align-text": { + "version": "0.1.4", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "3.2.2", + "longest": "1.0.1", + "repeat-string": "1.6.1" + } + }, + "amdefine": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "ansi-regex": { + "version": "3.0.0", + "bundled": true, + "dev": true + }, + "append-transform": { + "version": "0.4.0", + "bundled": true, + "dev": true, + "requires": { + "default-require-extensions": "1.0.0" + } + }, + "archy": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "arr-diff": { + "version": "4.0.0", + "bundled": true, + "dev": true + }, + "arr-flatten": { + "version": "1.1.0", + "bundled": true, + "dev": true + }, + "arr-union": { + "version": "3.1.0", + "bundled": true, + "dev": true + }, + "array-unique": { + "version": "0.3.2", + "bundled": true, + "dev": true + }, + "arrify": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "assign-symbols": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "async": { + "version": "1.5.2", + "bundled": true, + "dev": true + }, + "atob": { + "version": "2.1.1", + "bundled": true, + "dev": true + }, + "balanced-match": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "base": { + "version": "0.11.2", + "bundled": true, + "dev": true, + "requires": { + "cache-base": "1.0.1", + "class-utils": "0.3.6", + "component-emitter": "1.2.1", + "define-property": "1.0.0", + "isobject": "3.0.1", + "mixin-deep": "1.3.1", + "pascalcase": "0.1.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "brace-expansion": { + "version": "1.1.11", + "bundled": true, + "dev": true, + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "2.3.2", + "bundled": true, + "dev": true, + "requires": { + "arr-flatten": "1.1.0", + "array-unique": "0.3.2", + "extend-shallow": "2.0.1", + "fill-range": "4.0.0", + "isobject": "3.0.1", + "repeat-element": "1.1.2", + "snapdragon": "0.8.2", + "snapdragon-node": "2.1.1", + "split-string": "3.1.0", + "to-regex": "3.0.2" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "builtin-modules": { + "version": "1.1.1", + "bundled": true, + "dev": true + }, + "cache-base": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "collection-visit": "1.0.0", + "component-emitter": "1.2.1", + "get-value": "2.0.6", + "has-value": "1.0.0", + "isobject": "3.0.1", + "set-value": "2.0.0", + "to-object-path": "0.3.0", + "union-value": "1.0.0", + "unset-value": "1.0.0" + } + }, + "caching-transform": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "md5-hex": "1.3.0", + "mkdirp": "0.5.1", + "write-file-atomic": "1.3.4" + } + }, + "camelcase": { + "version": "1.2.1", + "bundled": true, + "dev": true, + "optional": true + }, + "center-align": { + "version": "0.1.3", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "align-text": "0.1.4", + "lazy-cache": "1.0.4" + } + }, + "class-utils": { + "version": "0.3.6", + "bundled": true, + "dev": true, + "requires": { + "arr-union": "3.1.0", + "define-property": "0.2.5", + "isobject": "3.0.1", + "static-extend": "0.1.2" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + } + } + }, + "cliui": { + "version": "2.1.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "center-align": "0.1.3", + "right-align": "0.1.3", + "wordwrap": "0.0.2" + }, + "dependencies": { + "wordwrap": { + "version": "0.0.2", + "bundled": true, + "dev": true, + "optional": true + } + } + }, + "code-point-at": { + "version": "1.1.0", + "bundled": true, + "dev": true + }, + "collection-visit": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "map-visit": "1.0.0", + "object-visit": "1.0.1" + } + }, + "commondir": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "component-emitter": { + "version": "1.2.1", + "bundled": true, + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "bundled": true, + "dev": true + }, + "convert-source-map": { + "version": "1.5.1", + "bundled": true, + "dev": true + }, + "copy-descriptor": { + "version": "0.1.1", + "bundled": true, + "dev": true + }, + "cross-spawn": { + "version": "4.0.2", + "bundled": true, + "dev": true, + "requires": { + "lru-cache": "4.1.3", + "which": "1.3.1" + } + }, + "debug": { + "version": "3.1.0", + "bundled": true, + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "debug-log": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "decamelize": { + "version": "1.2.0", + "bundled": true, + "dev": true + }, + "decode-uri-component": { + "version": "0.2.0", + "bundled": true, + "dev": true + }, + "default-require-extensions": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "strip-bom": "2.0.0" + } + }, + "define-property": { + "version": "2.0.2", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "1.0.2", + "isobject": "3.0.1" + }, + "dependencies": { + "is-accessor-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "error-ex": { + "version": "1.3.1", + "bundled": true, + "dev": true, + "requires": { + "is-arrayish": "0.2.1" + } + }, + "execa": { + "version": "0.7.0", + "bundled": true, + "dev": true, + "requires": { + "cross-spawn": "5.1.0", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" + }, + "dependencies": { + "cross-spawn": { + "version": "5.1.0", + "bundled": true, + "dev": true, + "requires": { + "lru-cache": "4.1.3", + "shebang-command": "1.2.0", + "which": "1.3.1" + } + } + } + }, + "expand-brackets": { + "version": "2.1.4", + "bundled": true, + "dev": true, + "requires": { + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "posix-character-classes": "0.1.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "bundled": true, + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + }, + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "extend-shallow": { + "version": "3.0.2", + "bundled": true, + "dev": true, + "requires": { + "assign-symbols": "1.0.0", + "is-extendable": "1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-plain-object": "2.0.4" + } + } + } + }, + "extglob": { + "version": "2.0.4", + "bundled": true, + "dev": true, + "requires": { + "array-unique": "0.3.2", + "define-property": "1.0.0", + "expand-brackets": "2.1.4", + "extend-shallow": "2.0.1", + "fragment-cache": "0.2.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "fill-range": { + "version": "4.0.0", + "bundled": true, + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-number": "3.0.0", + "repeat-string": "1.6.1", + "to-regex-range": "2.1.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "find-cache-dir": { + "version": "0.1.1", + "bundled": true, + "dev": true, + "requires": { + "commondir": "1.0.1", + "mkdirp": "0.5.1", + "pkg-dir": "1.0.0" + } + }, + "find-up": { + "version": "2.1.0", + "bundled": true, + "dev": true, + "requires": { + "locate-path": "2.0.0" + } + }, + "for-in": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "foreground-child": { + "version": "1.5.6", + "bundled": true, + "dev": true, + "requires": { + "cross-spawn": "4.0.2", + "signal-exit": "3.0.2" + } + }, + "fragment-cache": { + "version": "0.2.1", + "bundled": true, + "dev": true, + "requires": { + "map-cache": "0.2.2" + } + }, + "fs.realpath": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "get-caller-file": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "get-stream": { + "version": "3.0.0", + "bundled": true, + "dev": true + }, + "get-value": { + "version": "2.0.6", + "bundled": true, + "dev": true + }, + "glob": { + "version": "7.1.2", + "bundled": true, + "dev": true, + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "bundled": true, + "dev": true + }, + "handlebars": { + "version": "4.0.11", + "bundled": true, + "dev": true, + "requires": { + "async": "1.5.2", + "optimist": "0.6.1", + "source-map": "0.4.4", + "uglify-js": "2.8.29" + }, + "dependencies": { + "source-map": { + "version": "0.4.4", + "bundled": true, + "dev": true, + "requires": { + "amdefine": "1.0.1" + } + } + } + }, + "has-value": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "get-value": "2.0.6", + "has-values": "1.0.0", + "isobject": "3.0.1" + } + }, + "has-values": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-number": "3.0.0", + "kind-of": "4.0.0" + }, + "dependencies": { + "kind-of": { + "version": "4.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "hosted-git-info": { + "version": "2.6.0", + "bundled": true, + "dev": true + }, + "imurmurhash": { + "version": "0.1.4", + "bundled": true, + "dev": true + }, + "inflight": { + "version": "1.0.6", + "bundled": true, + "dev": true, + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "bundled": true, + "dev": true + }, + "invert-kv": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "is-accessor-descriptor": { + "version": "0.1.6", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-arrayish": { + "version": "0.2.1", + "bundled": true, + "dev": true + }, + "is-buffer": { + "version": "1.1.6", + "bundled": true, + "dev": true + }, + "is-builtin-module": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "builtin-modules": "1.1.1" + } + }, + "is-data-descriptor": { + "version": "0.1.4", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-descriptor": { + "version": "0.1.6", + "bundled": true, + "dev": true, + "requires": { + "is-accessor-descriptor": "0.1.6", + "is-data-descriptor": "0.1.4", + "kind-of": "5.1.0" + }, + "dependencies": { + "kind-of": { + "version": "5.1.0", + "bundled": true, + "dev": true + } + } + }, + "is-extendable": { + "version": "0.1.1", + "bundled": true, + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "bundled": true, + "dev": true + }, + "is-number": { + "version": "3.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-odd": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-number": "4.0.0" + }, + "dependencies": { + "is-number": { + "version": "4.0.0", + "bundled": true, + "dev": true + } + } + }, + "is-plain-object": { + "version": "2.0.4", + "bundled": true, + "dev": true, + "requires": { + "isobject": "3.0.1" + } + }, + "is-stream": { + "version": "1.1.0", + "bundled": true, + "dev": true + }, + "is-utf8": { + "version": "0.2.1", + "bundled": true, + "dev": true + }, + "is-windows": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "isarray": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "isexe": { + "version": "2.0.0", + "bundled": true, + "dev": true + }, + "isobject": { + "version": "3.0.1", + "bundled": true, + "dev": true + }, + "istanbul-lib-coverage": { + "version": "1.2.0", + "bundled": true, + "dev": true + }, + "istanbul-lib-hook": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "append-transform": "0.4.0" + } + }, + "istanbul-lib-report": { + "version": "1.1.3", + "bundled": true, + "dev": true, + "requires": { + "istanbul-lib-coverage": "1.2.0", + "mkdirp": "0.5.1", + "path-parse": "1.0.5", + "supports-color": "3.2.3" + }, + "dependencies": { + "has-flag": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "supports-color": { + "version": "3.2.3", + "bundled": true, + "dev": true, + "requires": { + "has-flag": "1.0.0" + } + } + } + }, + "istanbul-lib-source-maps": { + "version": "1.2.5", + "bundled": true, + "dev": true, + "requires": { + "debug": "3.1.0", + "istanbul-lib-coverage": "1.2.0", + "mkdirp": "0.5.1", + "rimraf": "2.6.2", + "source-map": "0.5.7" + } + }, + "istanbul-reports": { + "version": "1.4.1", + "bundled": true, + "dev": true, + "requires": { + "handlebars": "4.0.11" + } + }, + "kind-of": { + "version": "3.2.2", + "bundled": true, + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + }, + "lazy-cache": { + "version": "1.0.4", + "bundled": true, + "dev": true, + "optional": true + }, + "lcid": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "invert-kv": "1.0.0" + } + }, + "load-json-file": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "strip-bom": "2.0.0" + } + }, + "locate-path": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "requires": { + "p-locate": "2.0.0", + "path-exists": "3.0.0" + }, + "dependencies": { + "path-exists": { + "version": "3.0.0", + "bundled": true, + "dev": true + } + } + }, + "longest": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "lru-cache": { + "version": "4.1.3", + "bundled": true, + "dev": true, + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + } + }, + "map-cache": { + "version": "0.2.2", + "bundled": true, + "dev": true + }, + "map-visit": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "object-visit": "1.0.1" + } + }, + "md5-hex": { + "version": "1.3.0", + "bundled": true, + "dev": true, + "requires": { + "md5-o-matic": "0.1.1" + } + }, + "md5-o-matic": { + "version": "0.1.1", + "bundled": true, + "dev": true + }, + "mem": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "mimic-fn": "1.2.0" + } + }, + "merge-source-map": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "source-map": "0.6.1" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "bundled": true, + "dev": true + } + } + }, + "micromatch": { + "version": "3.1.10", + "bundled": true, + "dev": true, + "requires": { + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "braces": "2.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "extglob": "2.0.4", + "fragment-cache": "0.2.1", + "kind-of": "6.0.2", + "nanomatch": "1.2.9", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "mimic-fn": { + "version": "1.2.0", + "bundled": true, + "dev": true + }, + "minimatch": { + "version": "3.0.4", + "bundled": true, + "dev": true, + "requires": { + "brace-expansion": "1.1.11" + } + }, + "minimist": { + "version": "0.0.8", + "bundled": true, + "dev": true + }, + "mixin-deep": { + "version": "1.3.1", + "bundled": true, + "dev": true, + "requires": { + "for-in": "1.0.2", + "is-extendable": "1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-plain-object": "2.0.4" + } + } + } + }, + "mkdirp": { + "version": "0.5.1", + "bundled": true, + "dev": true, + "requires": { + "minimist": "0.0.8" + } + }, + "ms": { + "version": "2.0.0", + "bundled": true, + "dev": true + }, + "nanomatch": { + "version": "1.2.9", + "bundled": true, + "dev": true, + "requires": { + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "fragment-cache": "0.2.1", + "is-odd": "2.0.0", + "is-windows": "1.0.2", + "kind-of": "6.0.2", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "normalize-package-data": { + "version": "2.4.0", + "bundled": true, + "dev": true, + "requires": { + "hosted-git-info": "2.6.0", + "is-builtin-module": "1.0.0", + "semver": "5.5.0", + "validate-npm-package-license": "3.0.3" + } + }, + "npm-run-path": { + "version": "2.0.2", + "bundled": true, + "dev": true, + "requires": { + "path-key": "2.0.1" + } + }, + "number-is-nan": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "object-assign": { + "version": "4.1.1", + "bundled": true, + "dev": true + }, + "object-copy": { + "version": "0.1.0", + "bundled": true, + "dev": true, + "requires": { + "copy-descriptor": "0.1.1", + "define-property": "0.2.5", + "kind-of": "3.2.2" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + } + } + }, + "object-visit": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "isobject": "3.0.1" + } + }, + "object.pick": { + "version": "1.3.0", + "bundled": true, + "dev": true, + "requires": { + "isobject": "3.0.1" + } + }, + "once": { + "version": "1.4.0", + "bundled": true, + "dev": true, + "requires": { + "wrappy": "1.0.2" + } + }, + "optimist": { + "version": "0.6.1", + "bundled": true, + "dev": true, + "requires": { + "minimist": "0.0.8", + "wordwrap": "0.0.3" + } + }, + "os-homedir": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "os-locale": { + "version": "2.1.0", + "bundled": true, + "dev": true, + "requires": { + "execa": "0.7.0", + "lcid": "1.0.0", + "mem": "1.1.0" + } + }, + "p-finally": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "p-limit": { + "version": "1.2.0", + "bundled": true, + "dev": true, + "requires": { + "p-try": "1.0.0" + } + }, + "p-locate": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "requires": { + "p-limit": "1.2.0" + } + }, + "p-try": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "parse-json": { + "version": "2.2.0", + "bundled": true, + "dev": true, + "requires": { + "error-ex": "1.3.1" + } + }, + "pascalcase": { + "version": "0.1.1", + "bundled": true, + "dev": true + }, + "path-exists": { + "version": "2.1.0", + "bundled": true, + "dev": true, + "requires": { + "pinkie-promise": "2.0.1" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "path-key": { + "version": "2.0.1", + "bundled": true, + "dev": true + }, + "path-parse": { + "version": "1.0.5", + "bundled": true, + "dev": true + }, + "path-type": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" + } + }, + "pify": { + "version": "2.3.0", + "bundled": true, + "dev": true + }, + "pinkie": { + "version": "2.0.4", + "bundled": true, + "dev": true + }, + "pinkie-promise": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "pinkie": "2.0.4" + } + }, + "pkg-dir": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "find-up": "1.1.2" + }, + "dependencies": { + "find-up": { + "version": "1.1.2", + "bundled": true, + "dev": true, + "requires": { + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" + } + } + } + }, + "posix-character-classes": { + "version": "0.1.1", + "bundled": true, + "dev": true + }, + "pseudomap": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "read-pkg": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "load-json-file": "1.1.0", + "normalize-package-data": "2.4.0", + "path-type": "1.1.0" + } + }, + "read-pkg-up": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "find-up": "1.1.2", + "read-pkg": "1.1.0" + }, + "dependencies": { + "find-up": { + "version": "1.1.2", + "bundled": true, + "dev": true, + "requires": { + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" + } + } + } + }, + "regex-not": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "extend-shallow": "3.0.2", + "safe-regex": "1.1.0" + } + }, + "repeat-element": { + "version": "1.1.2", + "bundled": true, + "dev": true + }, + "repeat-string": { + "version": "1.6.1", + "bundled": true, + "dev": true + }, + "require-directory": { + "version": "2.1.1", + "bundled": true, + "dev": true + }, + "require-main-filename": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "resolve-from": { + "version": "2.0.0", + "bundled": true, + "dev": true + }, + "resolve-url": { + "version": "0.2.1", + "bundled": true, + "dev": true + }, + "ret": { + "version": "0.1.15", + "bundled": true, + "dev": true + }, + "right-align": { + "version": "0.1.3", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "align-text": "0.1.4" + } + }, + "rimraf": { + "version": "2.6.2", + "bundled": true, + "dev": true, + "requires": { + "glob": "7.1.2" + } + }, + "safe-regex": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "requires": { + "ret": "0.1.15" + } + }, + "semver": { + "version": "5.5.0", + "bundled": true, + "dev": true + }, + "set-blocking": { + "version": "2.0.0", + "bundled": true, + "dev": true + }, + "set-value": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-extendable": "0.1.1", + "is-plain-object": "2.0.4", + "split-string": "3.1.0" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "shebang-command": { + "version": "1.2.0", + "bundled": true, + "dev": true, + "requires": { + "shebang-regex": "1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "signal-exit": { + "version": "3.0.2", + "bundled": true, + "dev": true + }, + "slide": { + "version": "1.1.6", + "bundled": true, + "dev": true + }, + "snapdragon": { + "version": "0.8.2", + "bundled": true, + "dev": true, + "requires": { + "base": "0.11.2", + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "map-cache": "0.2.2", + "source-map": "0.5.7", + "source-map-resolve": "0.5.2", + "use": "3.1.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "bundled": true, + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + }, + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "snapdragon-node": { + "version": "2.1.1", + "bundled": true, + "dev": true, + "requires": { + "define-property": "1.0.0", + "isobject": "3.0.1", + "snapdragon-util": "3.0.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "snapdragon-util": { + "version": "3.0.1", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "source-map": { + "version": "0.5.7", + "bundled": true, + "dev": true + }, + "source-map-resolve": { + "version": "0.5.2", + "bundled": true, + "dev": true, + "requires": { + "atob": "2.1.1", + "decode-uri-component": "0.2.0", + "resolve-url": "0.2.1", + "source-map-url": "0.4.0", + "urix": "0.1.0" + } + }, + "source-map-url": { + "version": "0.4.0", + "bundled": true, + "dev": true + }, + "spawn-wrap": { + "version": "1.4.2", + "bundled": true, + "dev": true, + "requires": { + "foreground-child": "1.5.6", + "mkdirp": "0.5.1", + "os-homedir": "1.0.2", + "rimraf": "2.6.2", + "signal-exit": "3.0.2", + "which": "1.3.1" + } + }, + "spdx-correct": { + "version": "3.0.0", + "bundled": true, + "dev": true, + "requires": { + "spdx-expression-parse": "3.0.0", + "spdx-license-ids": "3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.1.0", + "bundled": true, + "dev": true + }, + "spdx-expression-parse": { + "version": "3.0.0", + "bundled": true, + "dev": true, + "requires": { + "spdx-exceptions": "2.1.0", + "spdx-license-ids": "3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.0", + "bundled": true, + "dev": true + }, + "split-string": { + "version": "3.1.0", + "bundled": true, + "dev": true, + "requires": { + "extend-shallow": "3.0.2" + } + }, + "static-extend": { + "version": "0.1.2", + "bundled": true, + "dev": true, + "requires": { + "define-property": "0.2.5", + "object-copy": "0.1.0" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "bundled": true, + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + } + } + }, + "string-width": { + "version": "2.1.1", + "bundled": true, + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "bundled": true, + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + }, + "strip-bom": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "requires": { + "is-utf8": "0.2.1" + } + }, + "strip-eof": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "test-exclude": { + "version": "4.2.1", + "bundled": true, + "dev": true, + "requires": { + "arrify": "1.0.1", + "micromatch": "3.1.10", + "object-assign": "4.1.1", + "read-pkg-up": "1.0.1", + "require-main-filename": "1.0.1" + } + }, + "to-object-path": { + "version": "0.3.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "to-regex": { + "version": "3.0.2", + "bundled": true, + "dev": true, + "requires": { + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "regex-not": "1.0.2", + "safe-regex": "1.1.0" + } + }, + "to-regex-range": { + "version": "2.1.1", + "bundled": true, + "dev": true, + "requires": { + "is-number": "3.0.0", + "repeat-string": "1.6.1" + } + }, + "uglify-js": { + "version": "2.8.29", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "source-map": "0.5.7", + "uglify-to-browserify": "1.0.2", + "yargs": "3.10.0" + }, + "dependencies": { + "yargs": { + "version": "3.10.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "camelcase": "1.2.1", + "cliui": "2.1.0", + "decamelize": "1.2.0", + "window-size": "0.1.0" + } + } + } + }, + "uglify-to-browserify": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "optional": true + }, + "union-value": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "arr-union": "3.1.0", + "get-value": "2.0.6", + "is-extendable": "0.1.1", + "set-value": "0.4.3" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + }, + "set-value": { + "version": "0.4.3", + "bundled": true, + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-extendable": "0.1.1", + "is-plain-object": "2.0.4", + "to-object-path": "0.3.0" + } + } + } + }, + "unset-value": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "has-value": "0.3.1", + "isobject": "3.0.1" + }, + "dependencies": { + "has-value": { + "version": "0.3.1", + "bundled": true, + "dev": true, + "requires": { + "get-value": "2.0.6", + "has-values": "0.1.4", + "isobject": "2.1.0" + }, + "dependencies": { + "isobject": { + "version": "2.1.0", + "bundled": true, + "dev": true, + "requires": { + "isarray": "1.0.0" + } + } + } + }, + "has-values": { + "version": "0.1.4", + "bundled": true, + "dev": true + } + } + }, + "urix": { + "version": "0.1.0", + "bundled": true, + "dev": true + }, + "use": { + "version": "3.1.0", + "bundled": true, + "dev": true, + "requires": { + "kind-of": "6.0.2" + }, + "dependencies": { + "kind-of": { + "version": "6.0.2", + "bundled": true, + "dev": true + } + } + }, + "validate-npm-package-license": { + "version": "3.0.3", + "bundled": true, + "dev": true, + "requires": { + "spdx-correct": "3.0.0", + "spdx-expression-parse": "3.0.0" + } + }, + "which": { + "version": "1.3.1", + "bundled": true, + "dev": true, + "requires": { + "isexe": "2.0.0" + } + }, + "which-module": { + "version": "2.0.0", + "bundled": true, + "dev": true + }, + "window-size": { + "version": "0.1.0", + "bundled": true, + "dev": true, + "optional": true + }, + "wordwrap": { + "version": "0.0.3", + "bundled": true, + "dev": true + }, + "wrap-ansi": { + "version": "2.1.0", + "bundled": true, + "dev": true, + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "bundled": true, + "dev": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "string-width": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "strip-ansi": { + "version": "3.0.1", + "bundled": true, + "dev": true, + "requires": { + "ansi-regex": "2.1.1" + } + } + } + }, + "wrappy": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "write-file-atomic": { + "version": "1.3.4", + "bundled": true, + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "imurmurhash": "0.1.4", + "slide": "1.1.6" + } + }, + "y18n": { + "version": "3.2.1", + "bundled": true, + "dev": true + }, + "yallist": { + "version": "2.1.2", + "bundled": true, + "dev": true + }, + "yargs": { + "version": "11.1.0", + "bundled": true, + "dev": true, + "requires": { + "cliui": "4.1.0", + "decamelize": "1.2.0", + "find-up": "2.1.0", + "get-caller-file": "1.0.2", + "os-locale": "2.1.0", + "require-directory": "2.1.1", + "require-main-filename": "1.0.1", + "set-blocking": "2.0.0", + "string-width": "2.1.1", + "which-module": "2.0.0", + "y18n": "3.2.1", + "yargs-parser": "9.0.2" + }, + "dependencies": { + "camelcase": { + "version": "4.1.0", + "bundled": true, + "dev": true + }, + "cliui": { + "version": "4.1.0", + "bundled": true, + "dev": true, + "requires": { + "string-width": "2.1.1", + "strip-ansi": "4.0.0", + "wrap-ansi": "2.1.0" + } + }, + "yargs-parser": { + "version": "9.0.2", + "bundled": true, + "dev": true, + "requires": { + "camelcase": "4.1.0" + } + } + } + }, + "yargs-parser": { + "version": "8.1.0", + "bundled": true, + "dev": true, + "requires": { + "camelcase": "4.1.0" + }, + "dependencies": { + "camelcase": { + "version": "4.1.0", + "bundled": true, + "dev": true + } + } + } + } + }, + "oauth-sign": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", + "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-copy": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", + "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", + "dev": true, + "requires": { + "copy-descriptor": "0.1.1", + "define-property": "0.2.5", + "kind-of": "3.2.2" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + } + } + }, + "object-keys": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz", + "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==", + "dev": true + }, + "object-visit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", + "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", + "dev": true, + "requires": { + "isobject": "3.0.1" + }, + "dependencies": { + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "object.omit": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz", + "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=", + "dev": true, + "optional": true, + "requires": { + "for-own": "0.1.5", + "is-extendable": "0.1.1" + } + }, + "object.pick": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", + "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", + "dev": true, + "requires": { + "isobject": "3.0.1" + }, + "dependencies": { + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "on-finished": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz", + "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", + "requires": { + "ee-first": "1.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1.0.2" + } + }, + "onetime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz", + "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", + "dev": true, + "requires": { + "mimic-fn": "1.2.0" + } + }, + "optionator": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", + "requires": { + "deep-is": "0.1.3", + "fast-levenshtein": "2.0.6", + "levn": "0.3.0", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "1.0.0" + } + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=", + "dev": true + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=" + }, + "output-file-sync": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/output-file-sync/-/output-file-sync-1.1.2.tgz", + "integrity": "sha1-0KM+7+YaIF+suQCS6CZZjVJFznY=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "mkdirp": "0.5.1", + "object-assign": "4.1.1" + } + }, + "p-cancelable": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.3.0.tgz", + "integrity": "sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw==", + "dev": true + }, + "p-event": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-event/-/p-event-1.3.0.tgz", + "integrity": "sha1-jmtPT2XHK8W2/ii3XtqHT5akoIU=", + "dev": true, + "requires": { + "p-timeout": "1.2.1" + } + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=", + "dev": true + }, + "p-reduce": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-reduce/-/p-reduce-1.0.0.tgz", + "integrity": "sha1-GMKw3ZNqRpClKfgjH1ig/bakffo=", + "dev": true + }, + "p-timeout": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-1.2.1.tgz", + "integrity": "sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y=", + "dev": true, + "requires": { + "p-finally": "1.0.0" + } + }, + "pac-proxy-agent": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-2.0.2.tgz", + "integrity": "sha512-cDNAN1Ehjbf5EHkNY5qnRhGPUCp6SnpyVof5fRzN800QV1Y2OkzbH9rmjZkbBRa8igof903yOnjIl6z0SlAhxA==", + "requires": { + "agent-base": "4.2.0", + "debug": "3.1.0", + "get-uri": "2.0.1", + "http-proxy-agent": "2.1.0", + "https-proxy-agent": "2.2.1", + "pac-resolver": "3.0.0", + "raw-body": "2.3.3", + "socks-proxy-agent": "3.0.1" + } + }, + "pac-resolver": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-3.0.0.tgz", + "integrity": "sha512-tcc38bsjuE3XZ5+4vP96OfhOugrX+JcnpUbhfuc4LuXBLQhoTthOstZeoQJBDnQUDYzYmdImKsbz0xSl1/9qeA==", + "requires": { + "co": "4.6.0", + "degenerator": "1.0.4", + "ip": "1.1.5", + "netmask": "1.0.6", + "thunkify": "2.1.2" + } + }, + "package-json": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/package-json/-/package-json-4.0.1.tgz", + "integrity": "sha1-iGmgQBJTZhxMTKPabCEh7VVfXu0=", + "dev": true, + "requires": { + "got": "6.7.1", + "registry-auth-token": "3.3.2", + "registry-url": "3.1.0", + "semver": "5.5.0" + }, + "dependencies": { + "got": { + "version": "6.7.1", + "resolved": "https://registry.npmjs.org/got/-/got-6.7.1.tgz", + "integrity": "sha1-JAzQV4WpoY5WHcG0S0HHY+8ejbA=", + "dev": true, + "requires": { + "create-error-class": "3.0.2", + "duplexer3": "0.1.4", + "get-stream": "3.0.0", + "is-redirect": "1.0.0", + "is-retry-allowed": "1.1.0", + "is-stream": "1.1.0", + "lowercase-keys": "1.0.1", + "safe-buffer": "5.1.2", + "timed-out": "4.0.1", + "unzip-response": "2.0.1", + "url-parse-lax": "1.0.0" + } + } + } + }, + "packet-reader": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/packet-reader/-/packet-reader-0.3.1.tgz", + "integrity": "sha1-zWLmCvjX/qinBexP+ZCHHEaHHyc=" + }, + "parse": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/parse/-/parse-1.11.1.tgz", + "integrity": "sha1-VY5TnULZ+4khDggiCdbzsD1frtU=", + "requires": { + "babel-runtime": "6.26.0", + "ws": "3.3.3", + "xmlhttprequest": "1.8.0" + }, + "dependencies": { + "ws": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz", + "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==", + "requires": { + "async-limiter": "1.0.0", + "safe-buffer": "5.1.2", + "ultron": "1.1.1" + } + } + } + }, + "parse-glob": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz", + "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=", + "dev": true, + "optional": true, + "requires": { + "glob-base": "0.3.0", + "is-dotfile": "1.0.3", + "is-extglob": "1.0.0", + "is-glob": "2.0.1" + } + }, + "parseurl": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.2.tgz", + "integrity": "sha1-/CidTtiZMRlGDBViUyYs3I3mW/M=" + }, + "pascalcase": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", + "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", + "dev": true + }, + "path-dirname": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz", + "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-is-inside": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz", + "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=", + "dev": true + }, + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=", + "dev": true + }, + "path-proxy": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/path-proxy/-/path-proxy-1.0.0.tgz", + "integrity": "sha1-GOijaFn8nS8aU7SN7hOFQ8Ag3l4=", + "requires": { + "inflection": "1.3.8" + }, + "dependencies": { + "inflection": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/inflection/-/inflection-1.3.8.tgz", + "integrity": "sha1-y9Fg2p91sUw8xjV41POWeEvzAU4=" + } + } + }, + "path-to-regexp": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", + "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w=" + }, + "path-type": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", + "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==", + "dev": true, + "requires": { + "pify": "3.0.0" + }, + "dependencies": { + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", + "dev": true + } + } + }, + "pause-stream": { + "version": "0.0.11", + "resolved": "https://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz", + "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=", + "dev": true, + "requires": { + "through": "2.3.8" + } + }, + "pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha1-elfrVQpng/kRUzH89GY9XI4AelA=", + "dev": true + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + }, + "pg": { + "version": "7.4.3", + "resolved": "https://registry.npmjs.org/pg/-/pg-7.4.3.tgz", + "integrity": "sha1-97b5P1NA7MJZavu5ShPj1rYJg0s=", + "requires": { + "buffer-writer": "1.0.1", + "packet-reader": "0.3.1", + "pg-connection-string": "0.1.3", + "pg-pool": "2.0.3", + "pg-types": "1.12.1", + "pgpass": "1.0.2", + "semver": "4.3.2" + }, + "dependencies": { + "semver": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-4.3.2.tgz", + "integrity": "sha1-x6BxWKgL7dBSNVt3DYLWZA+AO+c=" + } + } + }, + "pg-connection-string": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-0.1.3.tgz", + "integrity": "sha1-2hhHsglA5C7hSSvq9l1J2RskXfc=" + }, + "pg-minify": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/pg-minify/-/pg-minify-0.5.4.tgz", + "integrity": "sha512-GHB2v4OiMHDgwiHH86ZWNfvgEPVijrnfuWLQocseX6Zlf30k+x0imA65zBy4skIpEwfBBEplIEEKP4n3q9KkVA==" + }, + "pg-pool": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-2.0.3.tgz", + "integrity": "sha1-wCIDLIlJ8xKk+R+2QJzgQHa+Mlc=" + }, + "pg-promise": { + "version": "8.4.5", + "resolved": "https://registry.npmjs.org/pg-promise/-/pg-promise-8.4.5.tgz", + "integrity": "sha512-0KqI14s/y/KN142T+ingQugXwz8OZGkZIQESXLEN1Ei1kq9sZWpatAGNO6/Vr9tsZp6UN4a0V9YsHaLUszNyxw==", + "requires": { + "manakin": "0.5.1", + "pg": "7.4.3", + "pg-minify": "0.5.4", + "spex": "2.0.2" + } + }, + "pg-types": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-1.12.1.tgz", + "integrity": "sha1-1kCH45A7WP+q0nnnWVxSIIoUw9I=", + "requires": { + "postgres-array": "1.0.2", + "postgres-bytea": "1.0.0", + "postgres-date": "1.0.3", + "postgres-interval": "1.1.1" + } + }, + "pgpass": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.2.tgz", + "integrity": "sha1-Knu0G2BltnkH6R2hsHwYR8h3swY=", + "requires": { + "split": "1.0.1" + } + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", + "dev": true + }, + "pinkie-promise": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", + "dev": true, + "requires": { + "pinkie": "2.0.4" + } + }, + "pluralize": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz", + "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==", + "dev": true + }, + "posix-character-classes": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", + "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", + "dev": true + }, + "postgres-array": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-1.0.2.tgz", + "integrity": "sha1-jgsy6wO/d6XAp4UeBEHBaaJWojg=" + }, + "postgres-bytea": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz", + "integrity": "sha1-AntTPAqokOJtFy1Hz5zOzFIazTU=" + }, + "postgres-date": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.3.tgz", + "integrity": "sha1-4tiXAu/bJY/52c7g/pG9BpdSV6g=" + }, + "postgres-interval": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.1.1.tgz", + "integrity": "sha1-rNsPiXtLHG5JbZ1OCoU+HEKPBvA=", + "requires": { + "xtend": "4.0.1" + } + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=" + }, + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=", + "dev": true + }, + "preserve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz", + "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=", + "dev": true, + "optional": true + }, + "private": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", + "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==", + "dev": true + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==" + }, + "progress": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.0.tgz", + "integrity": "sha1-ihvjZr+Pwj2yvSPxDG/pILQ4nR8=", + "dev": true + }, + "promisify-call": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/promisify-call/-/promisify-call-2.0.4.tgz", + "integrity": "sha1-1IwtRWUszM1SgB3ey9UzptS9X7o=", + "requires": { + "with-callback": "1.0.2" + } + }, + "proto-list": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", + "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=", + "dev": true + }, + "proxy-addr": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.3.tgz", + "integrity": "sha512-jQTChiCJteusULxjBp8+jftSQE5Obdl3k4cnmLA6WXtK6XFuWRnvVL7aCiBqaLPM8c4ph0S4tKna8XvmIwEnXQ==", + "requires": { + "forwarded": "0.1.2", + "ipaddr.js": "1.6.0" + } + }, + "proxy-agent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-3.0.0.tgz", + "integrity": "sha1-9naOICiJsihdOZBtOpR2hBb49xM=", + "requires": { + "agent-base": "4.2.0", + "debug": "3.1.0", + "http-proxy-agent": "2.1.0", + "https-proxy-agent": "2.2.1", + "lru-cache": "4.1.2", + "pac-proxy-agent": "2.0.2", + "proxy-from-env": "1.0.0", + "socks-proxy-agent": "3.0.1" + } + }, + "proxy-from-env": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.0.0.tgz", + "integrity": "sha1-M8UDmPcOp+uW0h97gXYwpVeRx+4=" + }, + "ps-node": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/ps-node/-/ps-node-0.0.5.tgz", + "integrity": "sha1-hWe8VKX4MbRd2eAOWpwJVqr58ZY=", + "dev": true, + "requires": { + "table-parser": "1.0.1" + } + }, + "ps-tree": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/ps-tree/-/ps-tree-1.1.0.tgz", + "integrity": "sha1-tCGyQUDWID8e08dplrRCewjowBQ=", + "dev": true, + "requires": { + "event-stream": "3.3.4" + } + }, + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=" + }, + "pstree.remy": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.0.tgz", + "integrity": "sha512-q5I5vLRMVtdWa8n/3UEzZX7Lfghzrg9eG2IKk2ENLSofKRCXVqMvMUHxCKgXNaqH/8ebhBxrqftHWnyTFweJ5Q==", + "dev": true, + "requires": { + "ps-tree": "1.1.0" + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + }, + "qs": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz", + "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==" + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=" + }, + "randomatic": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-3.0.0.tgz", + "integrity": "sha512-VdxFOIEY3mNO5PtSRkkle/hPJDHvQhK21oa73K4yAc9qmp6N429gAyF1gZMOTMeS0/AYzaV/2Trcef+NaIonSA==", + "dev": true, + "optional": true, + "requires": { + "is-number": "4.0.0", + "kind-of": "6.0.2", + "math-random": "1.0.1" + }, + "dependencies": { + "is-number": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", + "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", + "dev": true, + "optional": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true, + "optional": true + } + } + }, + "range-parser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz", + "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=" + }, + "raw-body": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.3.tgz", + "integrity": "sha512-9esiElv1BrZoI3rCDuOuKCBRbuApGGaDPQfjSflGxdy4oyzqghxu6klEkkVIvBje+FF0BX9coEv8KqW6X/7njw==", + "requires": { + "bytes": "3.0.0", + "http-errors": "1.6.3", + "iconv-lite": "0.4.23", + "unpipe": "1.0.0" + } + }, + "rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dev": true, + "requires": { + "deep-extend": "0.6.0", + "ini": "1.3.5", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + } + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.2", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "readdirp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.1.0.tgz", + "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "minimatch": "3.0.4", + "readable-stream": "2.3.6", + "set-immediate-shim": "1.0.1" + } + }, + "redis": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/redis/-/redis-2.8.0.tgz", + "integrity": "sha512-M1OkonEQwtRmZv4tEWF2VgpG0JWJ8Fv1PhlgT5+B+uNq2cA3Rt1Yt/ryoR+vQNOQcIEgdCdfH0jr3bDpihAw1A==", + "requires": { + "double-ended-queue": "2.1.0-0", + "redis-commands": "1.3.5", + "redis-parser": "2.6.0" + } + }, + "redis-commands": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/redis-commands/-/redis-commands-1.3.5.tgz", + "integrity": "sha512-foGF8u6MXGFF++1TZVC6icGXuMYPftKXt1FBT2vrfU9ZATNtZJ8duRC5d1lEfE8hyVe3jhelHGB91oB7I6qLsA==" + }, + "redis-parser": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/redis-parser/-/redis-parser-2.6.0.tgz", + "integrity": "sha1-Uu0J2srBCPGmMcB+m2mUHnoZUEs=" + }, + "regenerate": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.3.3.tgz", + "integrity": "sha1-DDNtOYBVPXVcObWGrjsgqknIK38=", + "dev": true + }, + "regenerator-runtime": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz", + "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==" + }, + "regenerator-transform": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz", + "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "private": "0.1.8" + } + }, + "regex-cache": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz", + "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==", + "dev": true, + "optional": true, + "requires": { + "is-equal-shallow": "0.1.3" + } + }, + "regex-not": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", + "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", + "dev": true, + "requires": { + "extend-shallow": "3.0.2", + "safe-regex": "1.1.0" + } + }, + "regexp.prototype.flags": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.2.0.tgz", + "integrity": "sha512-ztaw4M1VqgMwl9HlPpOuiYgItcHlunW0He2fE6eNfT6E/CF2FtYi9ofOYe4mKntstYk0Fyh/rDRBdS3AnxjlrA==", + "dev": true, + "requires": { + "define-properties": "1.1.2" + } + }, + "regexpp": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-1.1.0.tgz", + "integrity": "sha512-LOPw8FpgdQF9etWMaAfG/WRthIdXJGYp4mJ2Jgn/2lpkbod9jPn0t9UqN7AxBOKNfzRbYyVfgc7Vk4t/MpnXgw==", + "dev": true + }, + "regexpu-core": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", + "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=", + "dev": true, + "requires": { + "regenerate": "1.3.3", + "regjsgen": "0.2.0", + "regjsparser": "0.1.5" + } + }, + "registry-auth-token": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-3.3.2.tgz", + "integrity": "sha512-JL39c60XlzCVgNrO+qq68FoNb56w/m7JYvGR2jT5iR1xBrUA3Mfx5Twk5rqTThPmQKMWydGmq8oFtDlxfrmxnQ==", + "dev": true, + "requires": { + "rc": "1.2.8", + "safe-buffer": "5.1.2" + } + }, + "registry-url": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-3.1.0.tgz", + "integrity": "sha1-PU74cPc93h138M+aOBQyRE4XSUI=", + "dev": true, + "requires": { + "rc": "1.2.8" + } + }, + "regjsgen": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", + "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=", + "dev": true + }, + "regjsparser": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", + "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", + "dev": true, + "requires": { + "jsesc": "0.5.0" + }, + "dependencies": { + "jsesc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=", + "dev": true + } + } + }, + "remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=" + }, + "repeat-element": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.2.tgz", + "integrity": "sha1-7wiaF40Ug7quTZPrmLT55OEdmQo=", + "dev": true + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", + "dev": true + }, + "repeating": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz", + "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", + "dev": true, + "requires": { + "is-finite": "1.0.2" + } + }, + "request": { + "version": "2.85.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.85.0.tgz", + "integrity": "sha512-8H7Ehijd4js+s6wuVPLjwORxD4zeuyjYugprdOXlPSqaApmL/QOy+EB/beICHVCHkGMKNh5rvihb5ov+IDw4mg==", + "requires": { + "aws-sign2": "0.7.0", + "aws4": "1.7.0", + "caseless": "0.12.0", + "combined-stream": "1.0.6", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.3.2", + "har-validator": "5.0.3", + "hawk": "6.0.2", + "http-signature": "1.2.0", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.18", + "oauth-sign": "0.8.2", + "performance-now": "2.1.0", + "qs": "6.5.2", + "safe-buffer": "5.1.2", + "stringstream": "0.0.6", + "tough-cookie": "2.3.4", + "tunnel-agent": "0.6.0", + "uuid": "3.2.1" + } + }, + "request-promise": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/request-promise/-/request-promise-4.2.2.tgz", + "integrity": "sha1-0epG1lSm7k+O5qT+oQGMIpEZBLQ=", + "dev": true, + "requires": { + "bluebird": "3.5.1", + "request-promise-core": "1.1.1", + "stealthy-require": "1.1.1", + "tough-cookie": "2.3.4" + } + }, + "request-promise-core": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.1.tgz", + "integrity": "sha1-Pu4AssWqgyOc+wTFcA2jb4HNCLY=", + "dev": true, + "requires": { + "lodash": "4.17.5" + } + }, + "require-uncached": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz", + "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", + "dev": true, + "requires": { + "caller-path": "0.1.0", + "resolve-from": "1.0.1" + }, + "dependencies": { + "resolve-from": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz", + "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=", + "dev": true + } + } + }, + "require_optional": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/require_optional/-/require_optional-1.0.1.tgz", + "integrity": "sha512-qhM/y57enGWHAe3v/NcwML6a3/vfESLe/sGM2dII+gEO0BpKRUkWZow/tyloNqJyN6kXSl3RyyM8Ll5D/sJP8g==", + "requires": { + "resolve-from": "2.0.0", + "semver": "5.5.0" + } + }, + "resolve-from": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-2.0.0.tgz", + "integrity": "sha1-lICrIOlP+h2egKgEx+oUdhGWa1c=" + }, + "resolve-url": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", + "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", + "dev": true + }, + "restore-cursor": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz", + "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", + "dev": true, + "requires": { + "onetime": "2.0.1", + "signal-exit": "3.0.2" + } + }, + "ret": { + "version": "0.1.15", + "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", + "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", + "dev": true + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "dev": true, + "requires": { + "glob": "7.1.2" + } + }, + "run-async": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", + "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", + "dev": true, + "requires": { + "is-promise": "2.1.0" + } + }, + "rxjs": { + "version": "5.5.11", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-5.5.11.tgz", + "integrity": "sha512-3bjO7UwWfA2CV7lmwYMBzj4fQ6Cq+ftHc2MvUe+WMS7wcdJ1LosDWmdjPQanYp2dBRj572p7PeU81JUxHKOcBA==", + "dev": true, + "requires": { + "symbol-observable": "1.0.1" + } + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" + }, + "safe-regex": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", + "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", + "dev": true, + "requires": { + "ret": "0.1.15" + } + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "saslprep": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/saslprep/-/saslprep-1.0.0.tgz", + "integrity": "sha512-5lvKUEQ7lAN5/vPl5d3k8FQeDbEamu9kizfATfLLWV5h6Mkh1xcieR1FSsJkcSRUk49lF2tAW8gzXWVwtwZVhw==", + "optional": true + }, + "sax": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.1.tgz", + "integrity": "sha1-e45lYZCyKOgaZq6nSEgNgozS03o=" + }, + "seek-bzip": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.5.tgz", + "integrity": "sha1-z+kXyz0nS8/6x5J1ivUxc+sfq9w=", + "dev": true, + "requires": { + "commander": "2.8.1" + }, + "dependencies": { + "commander": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.8.1.tgz", + "integrity": "sha1-Br42f+v9oMMwqh4qBy09yXYkJdQ=", + "dev": true, + "requires": { + "graceful-readlink": "1.0.1" + } + } + } + }, + "semver": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", + "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==" + }, + "semver-diff": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-2.1.0.tgz", + "integrity": "sha1-S7uEN8jTfksM8aaP1ybsbWRdbTY=", + "dev": true, + "requires": { + "semver": "5.5.0" + } + }, + "send": { + "version": "0.16.1", + "resolved": "https://registry.npmjs.org/send/-/send-0.16.1.tgz", + "integrity": "sha512-ElCLJdJIKPk6ux/Hocwhk7NFHpI3pVm/IZOYWqUmoxcgeyM+MpxHHKhb8QmlJDX1pU6WrgaHBkVNm73Sv7uc2A==", + "requires": { + "debug": "2.6.9", + "depd": "1.1.2", + "destroy": "1.0.4", + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "etag": "1.8.1", + "fresh": "0.5.2", + "http-errors": "1.6.3", + "mime": "1.4.1", + "ms": "2.0.0", + "on-finished": "2.3.0", + "range-parser": "1.2.0", + "statuses": "1.3.1" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "mime": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz", + "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ==" + }, + "statuses": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.3.1.tgz", + "integrity": "sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=" + } + } + }, + "serve-static": { + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.13.1.tgz", + "integrity": "sha512-hSMUZrsPa/I09VYFJwa627JJkNs0NrfL1Uzuup+GqHfToR2KcsXFymXSV90hoyw3M+msjFuQly+YzIH/q0MGlQ==", + "requires": { + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "parseurl": "1.3.2", + "send": "0.16.1" + } + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=" + }, + "set-immediate-shim": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", + "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=", + "dev": true + }, + "set-value": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.0.tgz", + "integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==", + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-extendable": "0.1.1", + "is-plain-object": "2.0.4", + "split-string": "3.1.0" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + } + } + }, + "setprototypeof": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", + "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==" + }, + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "dev": true, + "requires": { + "shebang-regex": "1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", + "dev": true + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=" + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=", + "dev": true + }, + "slice-ansi": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz", + "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0" + }, + "dependencies": { + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + } + } + }, + "smart-buffer": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-1.1.15.tgz", + "integrity": "sha1-fxFLW2X6s+KjWqd1uxLw0cZJvxY=" + }, + "snapdragon": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", + "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", + "dev": true, + "requires": { + "base": "0.11.2", + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "map-cache": "0.2.2", + "source-map": "0.5.7", + "source-map-resolve": "0.5.1", + "use": "3.1.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "snapdragon-node": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", + "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", + "dev": true, + "requires": { + "define-property": "1.0.0", + "isobject": "3.0.1", + "snapdragon-util": "3.0.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "1.0.2" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "6.0.2" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" + } + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true + } + } + }, + "snapdragon-util": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", + "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "sntp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/sntp/-/sntp-2.1.0.tgz", + "integrity": "sha512-FL1b58BDrqS3A11lJ0zEdnJ3UOKqVxawAkF3k7F0CVN7VQ34aZrV+G8BZ1WC9ZL7NyrwsW0oviwsWDgRuVYtJg==", + "requires": { + "hoek": "4.2.1" + } + }, + "socks": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/socks/-/socks-1.1.10.tgz", + "integrity": "sha1-W4t/x8jzQcU+0FbpKbe/Tei6e1o=", + "requires": { + "ip": "1.1.5", + "smart-buffer": "1.1.15" + } + }, + "socks-proxy-agent": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-3.0.1.tgz", + "integrity": "sha1-Lq58+OKoLTRWV2FTmn+XGMVhdlk=", + "requires": { + "agent-base": "4.2.0", + "socks": "1.1.10" + } + }, + "sort-keys": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/sort-keys/-/sort-keys-1.1.2.tgz", + "integrity": "sha1-RBttTTRnmPG05J6JIK37oOVD+a0=", + "dev": true, + "requires": { + "is-plain-obj": "1.1.0" + } + }, + "sort-keys-length": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/sort-keys-length/-/sort-keys-length-1.0.1.tgz", + "integrity": "sha1-nLb09OnkgVWmqgZx7dM2/xR5oYg=", + "dev": true, + "requires": { + "sort-keys": "1.1.2" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "optional": true + }, + "source-map-resolve": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.1.tgz", + "integrity": "sha1-etD1k/IoFZjoVN+A8ZquS5LXoRo=", + "dev": true, + "requires": { + "atob": "2.1.1", + "decode-uri-component": "0.2.0", + "resolve-url": "0.2.1", + "source-map-url": "0.4.0", + "urix": "0.1.0" + } + }, + "source-map-support": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz", + "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==", + "dev": true, + "requires": { + "source-map": "0.5.7" + }, + "dependencies": { + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "source-map-url": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz", + "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", + "dev": true + }, + "spex": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/spex/-/spex-2.0.2.tgz", + "integrity": "sha512-LU6TS3qTEpRth+FnNs/fIWEmridYN7JmaN2k1Jk31XVC4ex7+wYxiHMnKguRxS7oKjbOFl4H6seeWNDFFgkVRg==" + }, + "split": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/split/-/split-1.0.1.tgz", + "integrity": "sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==", + "requires": { + "through": "2.3.8" + } + }, + "split-string": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", + "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", + "dev": true, + "requires": { + "extend-shallow": "3.0.2" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + }, + "sshpk": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.1.tgz", + "integrity": "sha1-Ew9Zde3a2WPx1W+SuaxsUfqfg+s=", + "requires": { + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" + } + }, + "stack-trace": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", + "integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=" + }, + "static-extend": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", + "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", + "dev": true, + "requires": { + "define-property": "0.2.5", + "object-copy": "0.1.0" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "0.1.6" + } + } + } + }, + "statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=" + }, + "stealthy-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz", + "integrity": "sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks=", + "dev": true + }, + "stream-combiner": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.0.4.tgz", + "integrity": "sha1-TV5DPBhSYd3mI8o/RMWGvPXErRQ=", + "dev": true, + "requires": { + "duplexer": "0.1.1" + } + }, + "streamsearch": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-0.1.2.tgz", + "integrity": "sha1-gIudDlb8Jz2Am6VzOOkpkZoanxo=" + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "string.prototype.matchall": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-2.0.0.tgz", + "integrity": "sha512-WoZ+B2ypng1dp4iFLF2kmZlwwlE19gmjgKuhL1FJfDgCREWb3ye3SDVHSzLH6bxfnvYmkCxbzkmWcQZHA4P//Q==", + "dev": true, + "requires": { + "define-properties": "1.1.2", + "es-abstract": "1.12.0", + "function-bind": "1.1.1", + "has-symbols": "1.0.0", + "regexp.prototype.flags": "1.2.0" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "5.1.2" + } + }, + "stringstream": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.6.tgz", + "integrity": "sha512-87GEBAkegbBcweToUrdzf3eLhWNg06FJTebl4BVJz/JgWy8CvEr9dRtX5qWphiynMSQlxxi+QqN0z5T32SLlhA==" + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + } + }, + "strip-dirs": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz", + "integrity": "sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==", + "dev": true, + "requires": { + "is-natural-number": "4.0.1" + } + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", + "dev": true + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", + "dev": true + }, + "strip-outer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/strip-outer/-/strip-outer-1.0.1.tgz", + "integrity": "sha512-k55yxKHwaXnpYGsOzg4Vl8+tDrWylxDEpknGjhTiZB8dFRU5rTo9CAzeycivxV3s+zlTKwrs6WxMxR95n26kwg==", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "dev": true, + "requires": { + "has-flag": "3.0.0" + } + }, + "symbol-observable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.0.1.tgz", + "integrity": "sha1-g0D8RwLDEi310iKI+IKD9RPT/dQ=", + "dev": true + }, + "table": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/table/-/table-4.0.3.tgz", + "integrity": "sha512-S7rnFITmBH1EnyKcvxBh1LjYeQMmnZtCXSEbHcH6S0NoKit24ZuFO/T1vDcLdYsLQkM188PVVhQmzKIuThNkKg==", + "dev": true, + "requires": { + "ajv": "6.5.1", + "ajv-keywords": "3.2.0", + "chalk": "2.4.1", + "lodash": "4.17.5", + "slice-ansi": "1.0.0", + "string-width": "2.1.1" + }, + "dependencies": { + "ajv": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.5.1.tgz", + "integrity": "sha512-pgZos1vgOHDiC7gKNbZW8eKvCnNXARv2oqrGQT7Hzbq5Azp7aZG6DJzADnkuSq7RH6qkXp4J/m68yPX/2uBHyQ==", + "dev": true, + "requires": { + "fast-deep-equal": "2.0.1", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.4.1", + "uri-js": "4.2.2" + } + }, + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "fast-deep-equal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz", + "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha1-q5Pyeo3BPSjKyBXEYhQ6bZASrp4=", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "dev": true, + "requires": { + "has-flag": "3.0.0" + } + } + } + }, + "table-parser": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/table-parser/-/table-parser-1.0.1.tgz", + "integrity": "sha512-LtOZVj3mBWk9ChtZmYy1NCSgWshClqoCzgcj0r0VRY+xm9N4ii2NZyLHVbFhGrWsxVt5uPiVeaZDePoD3krrGA==", + "dev": true, + "requires": { + "@semantic-release/git": "4.0.3", + "connected-domain": "1.0.0" + } + }, + "tar-stream": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.1.tgz", + "integrity": "sha512-IFLM5wp3QrJODQFPm6/to3LJZrONdBY/otxcvDIQzu217zKye6yVR3hhi9lAjrC2Z+m/j5oDxMPb1qcd8cIvpA==", + "requires": { + "bl": "1.2.2", + "buffer-alloc": "1.2.0", + "end-of-stream": "1.4.1", + "fs-constants": "1.0.0", + "readable-stream": "2.3.6", + "to-buffer": "1.1.1", + "xtend": "4.0.1" + } + }, + "term-size": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/term-size/-/term-size-1.2.0.tgz", + "integrity": "sha1-RYuDiH8oj8Vtb/+/rSYuJmOO+mk=", + "dev": true, + "requires": { + "execa": "0.7.0" + }, + "dependencies": { + "execa": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.7.0.tgz", + "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", + "dev": true, + "requires": { + "cross-spawn": "5.1.0", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" + } + } + } + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", + "dev": true + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + }, + "through2": { + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz", + "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=", + "dev": true, + "requires": { + "readable-stream": "1.0.34", + "xtend": "4.0.1" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + } + } + }, + "thunkify": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/thunkify/-/thunkify-2.1.2.tgz", + "integrity": "sha1-+qDp0jDFGsyVyhOjYawFyn4EVT0=" + }, + "tildify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/tildify/-/tildify-1.2.0.tgz", + "integrity": "sha1-3OwD9V3Km3qj5bBPIYF+tW5jWIo=", + "dev": true, + "requires": { + "os-homedir": "1.0.2" + } + }, + "timed-out": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz", + "integrity": "sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=", + "dev": true + }, + "timers-ext": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/timers-ext/-/timers-ext-0.1.5.tgz", + "integrity": "sha512-tsEStd7kmACHENhsUPaxb8Jf8/+GZZxyNFQbZD07HQOyooOa6At1rQqjffgvg7n+dxscQa9cjjMdWhJtsP2sxg==", + "dev": true, + "requires": { + "es5-ext": "0.10.45", + "next-tick": "1.0.0" + } + }, + "tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "requires": { + "os-tmpdir": "1.0.2" + } + }, + "to-buffer": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.1.1.tgz", + "integrity": "sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==" + }, + "to-fast-properties": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz", + "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=", + "dev": true + }, + "to-object-path": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", + "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "to-regex": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", + "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", + "dev": true, + "requires": { + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "regex-not": "1.0.2", + "safe-regex": "1.1.0" + } + }, + "to-regex-range": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", + "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", + "dev": true, + "requires": { + "is-number": "3.0.0", + "repeat-string": "1.6.1" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + } + } + }, + "touch": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.0.tgz", + "integrity": "sha512-WBx8Uy5TLtOSRtIq+M03/sKDrXCLHxwDcquSP2c43Le03/9serjQBIztjRz6FkJez9D/hleyAXTBGLwwZUw9lA==", + "dev": true, + "requires": { + "nopt": "1.0.10" + } + }, + "tough-cookie": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.4.tgz", + "integrity": "sha512-TZ6TTfI5NtZnuyy/Kecv+CnoROnyXn2DN97LontgQpCwsX2XyLYCC0ENhYkehSOwAp8rTQKc/NUIF7BkQ5rKLA==", + "requires": { + "punycode": "1.4.1" + } + }, + "trim-repeated": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/trim-repeated/-/trim-repeated-1.0.0.tgz", + "integrity": "sha1-42RqLqTokTEr9+rObPsFOAvAHCE=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5" + } + }, + "trim-right": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz", + "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=", + "dev": true + }, + "tsscmp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tsscmp/-/tsscmp-1.0.5.tgz", + "integrity": "sha1-fcSjOvcVgatDN9qR2FylQn69mpc=" + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "5.1.2" + } + }, + "tv4": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/tv4/-/tv4-1.3.0.tgz", + "integrity": "sha1-0CDIRvrdUMhVq7JeuuzGj8EPeWM=" + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "optional": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "requires": { + "prelude-ls": "1.1.2" + } + }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==" + }, + "type-is": { + "version": "1.6.16", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz", + "integrity": "sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==", + "requires": { + "media-typer": "0.3.0", + "mime-types": "2.1.18" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + }, + "ultron": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz", + "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==" + }, + "unbzip2-stream": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.2.5.tgz", + "integrity": "sha512-izD3jxT8xkzwtXRUZjtmRwKnZoeECrfZ8ra/ketwOcusbZEp4mjULMnJOCfTDZBgGQAAY1AJ/IgxcwkavcX9Og==", + "dev": true, + "requires": { + "buffer": "3.6.0", + "through": "2.3.8" + }, + "dependencies": { + "base64-js": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-0.0.8.tgz", + "integrity": "sha1-EQHpVE9KdrG8OybUUsqW16NeeXg=", + "dev": true + }, + "buffer": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-3.6.0.tgz", + "integrity": "sha1-pyyTb3e5a/UvX357RnGAYoVR3vs=", + "dev": true, + "requires": { + "base64-js": "0.0.8", + "ieee754": "1.1.8", + "isarray": "1.0.0" + } + } + } + }, + "undefsafe": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.2.tgz", + "integrity": "sha1-Il9rngM3Zj4Njnz9aG/Cg2zKznY=", + "dev": true, + "requires": { + "debug": "2.6.9" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + } + } + }, + "union-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.0.tgz", + "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=", + "dev": true, + "requires": { + "arr-union": "3.1.0", + "get-value": "2.0.6", + "is-extendable": "0.1.1", + "set-value": "0.4.3" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "0.1.1" + } + }, + "set-value": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/set-value/-/set-value-0.4.3.tgz", + "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=", + "dev": true, + "requires": { + "extend-shallow": "2.0.1", + "is-extendable": "0.1.1", + "is-plain-object": "2.0.4", + "to-object-path": "0.3.0" + } + } + } + }, + "unique-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-1.0.0.tgz", + "integrity": "sha1-nhBXzKhRq7kzmPizOuGHuZyuwRo=", + "dev": true, + "requires": { + "crypto-random-string": "1.0.0" + } + }, + "universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=" + }, + "unset-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", + "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", + "dev": true, + "requires": { + "has-value": "0.3.1", + "isobject": "3.0.1" + }, + "dependencies": { + "has-value": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", + "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", + "dev": true, + "requires": { + "get-value": "2.0.6", + "has-values": "0.1.4", + "isobject": "2.1.0" + }, + "dependencies": { + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "dev": true, + "requires": { + "isarray": "1.0.0" + } + } + } + }, + "has-values": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", + "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", + "dev": true + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + } + } + }, + "untildify": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-3.0.3.tgz", + "integrity": "sha512-iSk/J8efr8uPT/Z4eSUywnqyrQU7DSdMfdqK4iWEaUVVmcP5JcnpRqmVMwcwcnmI1ATFNgC5V90u09tBynNFKA==", + "dev": true + }, + "unzip-response": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unzip-response/-/unzip-response-2.0.1.tgz", + "integrity": "sha1-0vD3N9FrBhXnKmk17QQhRXLVb5c=", + "dev": true + }, + "upath": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.1.0.tgz", + "integrity": "sha512-bzpH/oBhoS/QI/YtbkqCg6VEiPYjSZtrHQM6/QnJS6OL9pKUFLqb3aFh4Scvwm45+7iAgiMkLhSbaZxUqmrprw==", + "dev": true + }, + "update-notifier": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-2.5.0.tgz", + "integrity": "sha512-gwMdhgJHGuj/+wHJJs9e6PcCszpxR1b236igrOkUofGhqJuG+amlIKwApH1IW1WWl7ovZxsX49lMBWLxSdm5Dw==", + "dev": true, + "requires": { + "boxen": "1.3.0", + "chalk": "2.4.1", + "configstore": "3.1.2", + "import-lazy": "2.1.0", + "is-ci": "1.1.0", + "is-installed-globally": "0.1.0", + "is-npm": "1.0.0", + "latest-version": "3.1.0", + "semver-diff": "2.1.0", + "xdg-basedir": "3.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + } + } + }, + "uri-js": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz", + "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==", + "dev": true, + "requires": { + "punycode": "2.1.1" + }, + "dependencies": { + "punycode": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", + "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", + "dev": true + } + } + }, + "urix": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", + "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", + "dev": true + }, + "url": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/url/-/url-0.10.3.tgz", + "integrity": "sha1-Ah5NnHcF8hu/N9A861h2dAJ3TGQ=", + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=" + } + } + }, + "url-parse-lax": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz", + "integrity": "sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=", + "dev": true, + "requires": { + "prepend-http": "1.0.4" + } + }, + "url-to-options": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/url-to-options/-/url-to-options-1.0.1.tgz", + "integrity": "sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=", + "dev": true + }, + "use": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/use/-/use-3.1.0.tgz", + "integrity": "sha1-FHFr8D/f79AwQK71jYtLhfOnxUQ=", + "dev": true, + "requires": { + "kind-of": "6.0.2" + }, + "dependencies": { + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha1-ARRrNqYhjmTljzqNZt5df8b20FE=", + "dev": true + } + } + }, + "user-home": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/user-home/-/user-home-1.1.1.tgz", + "integrity": "sha1-K1viOjK2Onyd640PKNSFcko98ZA=", + "dev": true + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=" + }, + "uuid": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.2.1.tgz", + "integrity": "sha512-jZnMwlb9Iku/O3smGWvZhauCf6cvvpKi4BKRiliS3cxnI+Gz9j5MEpTz2UFuXiKPJocb7gnsLHwiS05ige5BEA==" + }, + "uws": { + "version": "10.148.1", + "resolved": "https://registry.npmjs.org/uws/-/uws-10.148.1.tgz", + "integrity": "sha1-/Rp5z2EYo4jgob7YoTlwMNLE/Sw=", + "optional": true + }, + "v8flags": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/v8flags/-/v8flags-2.1.1.tgz", + "integrity": "sha1-qrGh+jDUX4jdMhFIh1rALAtV5bQ=", + "dev": true, + "requires": { + "user-home": "1.1.1" + } + }, + "vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=" + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "requires": { + "assert-plus": "1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "1.3.0" + } + }, + "walkdir": { + "version": "0.0.11", + "resolved": "https://registry.npmjs.org/walkdir/-/walkdir-0.0.11.tgz", + "integrity": "sha1-oW0CXrkxvQO1LzCMrtD0D86+lTI=" + }, + "which": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz", + "integrity": "sha1-/wS9/AEO5UfXgL7DjhrBwnd9JTo=", + "dev": true, + "requires": { + "isexe": "2.0.0" + } + }, + "wide-align": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.2.tgz", + "integrity": "sha1-Vx4PGwYEY268DfwhsDObvjE0FxA=", + "requires": { + "string-width": "1.0.2" + } + }, + "widest-line": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-2.0.0.tgz", + "integrity": "sha1-AUKk6KJD+IgsAjOqDgKBqnYVInM=", + "dev": true, + "requires": { + "string-width": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + } + } + }, + "winston": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/winston/-/winston-2.4.1.tgz", + "integrity": "sha1-o6kmUQVWQmPGeFtFg7jIrKJv3tY=", + "requires": { + "async": "1.0.0", + "colors": "1.0.3", + "cycle": "1.0.3", + "eyes": "0.1.8", + "isstream": "0.1.2", + "stack-trace": "0.0.10" + }, + "dependencies": { + "async": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async/-/async-1.0.0.tgz", + "integrity": "sha1-+PwEyjoTeErenhZBr5hXjPvWR6k=" + } + } + }, + "winston-daily-rotate-file": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/winston-daily-rotate-file/-/winston-daily-rotate-file-1.7.2.tgz", + "integrity": "sha1-ZQK/opeCT9mC2l5WR8dThXjS+aA=", + "requires": { + "mkdirp": "0.5.1" + } + }, + "with-callback": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/with-callback/-/with-callback-1.0.2.tgz", + "integrity": "sha1-oJYpuakgAo1yFAT7Q1vc/1yRvCE=" + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=" + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "write": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz", + "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", + "dev": true, + "requires": { + "mkdirp": "0.5.1" + } + }, + "write-file-atomic": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.3.0.tgz", + "integrity": "sha512-xuPeK4OdjWqtfi59ylvVL0Yn35SF3zgcAcv7rBPFHVaEapaDr4GdGgm3j7ckTwH9wHL7fGmgfAnb0+THrHb8tA==", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "imurmurhash": "0.1.4", + "signal-exit": "3.0.2" + } + }, + "ws": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-6.0.0.tgz", + "integrity": "sha512-c2UlYcAZp1VS8AORtpq6y4RJIkJ9dQz18W32SpR/qXGfLDZ2jU4y4wKvvZwqbi7U6gxFQTeE+urMbXU/tsDy4w==", + "requires": { + "async-limiter": "1.0.0" + } + }, + "xdg-basedir": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-3.0.0.tgz", + "integrity": "sha1-SWsswQnsqNus/i3HK2A8F8WHCtQ=", + "dev": true + }, + "xml2js": { + "version": "0.4.17", + "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.17.tgz", + "integrity": "sha1-F76T6q4/O3eTWceVtBlwWogX6Gg=", + "requires": { + "sax": "1.2.1", + "xmlbuilder": "4.2.1" + } + }, + "xmlbuilder": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-4.2.1.tgz", + "integrity": "sha1-qlijBBoGb5DqoWwvU4n/GfP0YaU=", + "requires": { + "lodash": "4.17.5" + } + }, + "xmlhttprequest": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz", + "integrity": "sha1-Z/4HXFwk/vOfnWX197f+dRcZaPw=" + }, + "xregexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/xregexp/-/xregexp-2.0.0.tgz", + "integrity": "sha1-UqY+VsoLhKfzpfPWGHLxJq16WUM=" + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=" + }, + "yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=", + "dev": true, + "requires": { + "buffer-crc32": "0.2.13", + "fd-slicer": "1.1.0" + } + }, + "zip-stream": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-1.2.0.tgz", + "integrity": "sha1-qLxF9MG0lpnGuQGYuqyqzbzUugQ=", + "requires": { + "archiver-utils": "1.3.0", + "compress-commons": "1.2.2", + "lodash": "4.17.5", + "readable-stream": "2.3.6" + } + } + } +} diff --git a/package.json b/package.json index a0b13451cb..52ee34d99f 100644 --- a/package.json +++ b/package.json @@ -1,11 +1,11 @@ { "name": "parse-server", - "version": "2.7.4", + "version": "2.8.4", "description": "An express module providing a Parse-compatible API server", "main": "lib/index.js", "repository": { "type": "git", - "url": "https://github.com/ParsePlatform/parse-server" + "url": "https://github.com/parse-community/parse-server" }, "files": [ "bin/", @@ -14,38 +14,39 @@ "views/", "LICENSE", "PATENTS", + "postinstall.js", "README.md" ], "license": "BSD-3-Clause", "dependencies": { "@parse/fs-files-adapter": "1.0.1", - "@parse/push-adapter": "2.0.2", + "@parse/push-adapter": "3.0.0-alpha2", "@parse/s3-files-adapter": "1.2.1", - "@parse/simple-mailgun-adapter": "1.0.1", + "@parse/simple-mailgun-adapter": "1.0.2", "adm-zip": "0.4.7", "archiver": "1.3.0", "bcryptjs": "2.4.3", - "body-parser": "1.18.2", - "commander": "2.15.0", - "deepcopy": "0.6.3", + "body-parser": "1.18.3", + "commander": "2.16.0", + "deepcopy": "1.0.0", "express": "4.16.2", "intersect": "1.0.1", "lodash": "4.17.5", "lru-cache": "4.1.2", - "mime": "2.2.0", - "mongodb": "3.0.4", - "multer": "1.3.0", + "mime": "2.3.1", + "mongodb": "3.1.1", + "multer": "^1.3.1", "parse": "1.11.1", - "pg-promise": "8.2.1", + "pg-promise": "8.4.5", "redis": "2.8.0", - "request": "2.83.0", + "request": "2.85.0", "semver": "5.5.0", "tmp": "0.0.33", "tv4": "1.3.0", "uuid": "^3.1.0", "winston": "2.4.1", "winston-daily-rotate-file": "1.7.2", - "ws": "5.0.0" + "ws": "6.0.0" }, "devDependencies": { "babel-cli": "6.26.0", @@ -55,38 +56,41 @@ "babel-plugin-transform-object-rest-spread": "^6.26.0", "babel-preset-env": "1.6.1", "bcrypt-nodejs": "0.0.3", - "cross-env": "5.1.4", - "deep-diff": "0.3.8", - "eslint": "^4.9.0", + "cross-env": "5.2.0", + "deep-diff": "1.0.1", + "eslint": "^5.0.0", "eslint-plugin-flowtype": "^2.39.1", - "flow-bin": "^0.67.1", - "gaze": "1.1.2", + "flow-bin": "^0.76.0", + "gaze": "1.1.3", "jasmine": "3.1.0", "jasmine-spec-reporter": "^4.1.0", - "mongodb-runner": "3.6.1", - "nodemon": "1.17.1", - "nyc": "^11.0.2", - "request-promise": "4.2.2" + "mongodb-runner": "4.0.0", + "nodemon": "1.18.1", + "nyc": "^12.0.2", + "request-promise": "4.2.2", + "supports-color": "^5.4.0" }, "scripts": { "dev": "npm run build && node bin/dev", "lint": "flow && eslint --cache ./", "build": "babel src/ -d lib/ --copy-files", + "watch": "babel --watch src/ -d lib/ --copy-files", "pretest": "npm run lint", "test": "cross-env MONGODB_VERSION=${MONGODB_VERSION:=3.2.6} MONGODB_STORAGE_ENGINE=mmapv1 TESTING=1 jasmine", "coverage": "cross-env MONGODB_VERSION=${MONGODB_VERSION:=3.2.6} MONGODB_STORAGE_ENGINE=mmapv1 TESTING=1 nyc jasmine", "start": "node ./bin/parse-server", - "prepublish": "npm run build" + "prepare": "npm run build", + "postinstall": "node -p 'require(\"./postinstall.js\")()'" }, "engines": { - "node": ">=6.11.4" + "node": ">= 8" }, "bin": { "parse-server": "./bin/parse-server" }, "optionalDependencies": { - "bcrypt": "1.0.3", - "uws": "^9.14.0" + "bcrypt": "3.0.0", + "uws": "10.148.1" }, "collective": { "type": "opencollective", diff --git a/postinstall.js b/postinstall.js new file mode 100644 index 0000000000..fef1fb31ff --- /dev/null +++ b/postinstall.js @@ -0,0 +1,50 @@ +const pkg = require('./package.json'); + +const version = parseFloat(process.version.substr(1)); +const minimum = parseFloat(pkg.engines.node.match(/\d+/g).join('.')); + +module.exports = function () { + const openCollective = ` + 1111111111 + 1111111111111111 + 1111111111111111111111 + 11111111111111111111111111 + 111111111111111 11111111 + 1111111111111 111111 + 1111111111111 111111111 111111 + 111111111111 11111111111 111111 + 1111111111111 11111111111 111111 + 1111111111111 1111111111 111111 + 1111111111111111111111111 1111111 + 11111111 11111111 + 111111 1111111111111111111 + 11111 11111 111111111111111111 + 11111 11111111111111111 + 111111 111111111111111111 + 11111111111111111111111111 + 1111111111111111111111 + 111111111111111111 + 11111111111 + + + Thanks for installing parse 🙏 + Please consider donating to our open collective + to help us maintain this package. + + 👉 https://opencollective.com/parse-server + + `; + process.stdout.write(openCollective); + if (version >= minimum) { + process.exit(0); + } + + const errorMessage = ` + ⚠️ parse-server requires at least node@${minimum}! + You have node@${version} + + `; + + process.stdout.write(errorMessage); + process.exit(1); +}; diff --git a/resources/npm-git.sh b/resources/npm-git.sh deleted file mode 100755 index c538b77fd7..0000000000 --- a/resources/npm-git.sh +++ /dev/null @@ -1,39 +0,0 @@ -#!/bin/sh -e - -# This script maintains a git branch which mirrors master but in a form that -# what will eventually be deployed to npm, allowing npm dependencies to use: -# -# "parse-server": "parseplatform/parse-server#latest" -# - -# From: https://github.com/graphql/graphql-js/blob/master/resources/npm-git.sh - -BUILD_DIR=latest -BRANCH="${TRAVIS_BRANCH}" -TARGET="latest" -if [ "$BRANCH" != "master" ]; -then - TARGET="$BRANCH-preview" -fi - -npm run build - -mkdir -p $BUILD_DIR - -cp package.json $BUILD_DIR/ -cp README.md $BUILD_DIR/ -cp LICENSE $BUILD_DIR/ -cp PATENTS $BUILD_DIR/ -cp CHANGELOG.md $BUILD_DIR/ -cp -R lib $BUILD_DIR -cp -R bin $BUILD_DIR -cp -R public_html $BUILD_DIR -cp -R views $BUILD_DIR - -cd $BUILD_DIR -git init -git config user.name "Travis CI" -git config user.email "github@fb.com" -git add . -git commit -m "Deploy $BRANCH to $TARGET branch" -git push --force --quiet "https://${GH_TOKEN}@github.com/parse-community/parse-server.git" master:$TARGET diff --git a/spec/.babelrc b/spec/.babelrc new file mode 100644 index 0000000000..a611705cd0 --- /dev/null +++ b/spec/.babelrc @@ -0,0 +1,14 @@ +{ + "plugins": [ + "transform-object-rest-spread" + ], + "presets": [ + ["env", { + "targets": { + "node": "8" + } + }] + ], + "sourceMaps": "inline", + "retainLines": true +} diff --git a/spec/AccountLockoutPolicy.spec.js b/spec/AccountLockoutPolicy.spec.js index 94d3067258..099b762c79 100644 --- a/spec/AccountLockoutPolicy.spec.js +++ b/spec/AccountLockoutPolicy.spec.js @@ -1,6 +1,6 @@ "use strict"; -const Config = require("../src/Config"); +const Config = require("../lib/Config"); const loginWithWrongCredentialsShouldFail = function(username, password) { return new Promise((resolve, reject) => { diff --git a/spec/AdaptableController.spec.js b/spec/AdaptableController.spec.js index 2bb61adde5..3e4ab74468 100644 --- a/spec/AdaptableController.spec.js +++ b/spec/AdaptableController.spec.js @@ -1,7 +1,7 @@ -const AdaptableController = require("../src/Controllers/AdaptableController").AdaptableController; -const FilesAdapter = require("../src/Adapters/Files/FilesAdapter").default; -const FilesController = require("../src/Controllers/FilesController").FilesController; +const AdaptableController = require("../lib/Controllers/AdaptableController").AdaptableController; +const FilesAdapter = require("../lib/Adapters/Files/FilesAdapter").default; +const FilesController = require("../lib/Controllers/FilesController").FilesController; const MockController = function(options) { AdaptableController.call(this, options); @@ -70,7 +70,7 @@ describe("AdaptableController", ()=>{ done(); }); - it("should accept an object adapter", (done) => { + it("should accept an prototype based object adapter", (done) => { function AGoodAdapter() {} AGoodAdapter.prototype.createFile = function() { }; AGoodAdapter.prototype.deleteFile = function() { }; diff --git a/spec/AdapterLoader.spec.js b/spec/AdapterLoader.spec.js index 7afec6fd67..334232f4a7 100644 --- a/spec/AdapterLoader.spec.js +++ b/spec/AdapterLoader.spec.js @@ -1,9 +1,9 @@ -const loadAdapter = require("../src/Adapters/AdapterLoader").loadAdapter; +const loadAdapter = require("../lib/Adapters/AdapterLoader").loadAdapter; const FilesAdapter = require("@parse/fs-files-adapter").default; const S3Adapter = require("@parse/s3-files-adapter").default; const ParsePushAdapter = require("@parse/push-adapter").default; -const Config = require('../src/Config'); +const Config = require('../lib/Config'); describe("AdapterLoader", ()=>{ @@ -33,7 +33,7 @@ describe("AdapterLoader", ()=>{ }); it("should instantiate an adapter from string that is module", (done) => { - const adapterPath = require('path').resolve("./src/Adapters/Files/FilesAdapter"); + const adapterPath = require('path').resolve("./lib/Adapters/Files/FilesAdapter"); const adapter = loadAdapter({ adapter: adapterPath }); diff --git a/spec/AudienceRouter.spec.js b/spec/AudienceRouter.spec.js index d5e635d665..6b977b8f31 100644 --- a/spec/AudienceRouter.spec.js +++ b/spec/AudienceRouter.spec.js @@ -1,7 +1,7 @@ -const auth = require('../src/Auth'); -const Config = require('../src/Config'); -const rest = require('../src/rest'); -const AudiencesRouter = require('../src/Routers/AudiencesRouter').AudiencesRouter; +const auth = require('../lib/Auth'); +const Config = require('../lib/Config'); +const rest = require('../lib/rest'); +const AudiencesRouter = require('../lib/Routers/AudiencesRouter').AudiencesRouter; describe('AudiencesRouter', () => { it('uses find condition from request.body', (done) => { diff --git a/spec/Auth.spec.js b/spec/Auth.spec.js index 5802f72d31..a4d97639f0 100644 --- a/spec/Auth.spec.js +++ b/spec/Auth.spec.js @@ -1,5 +1,5 @@ describe('Auth', () => { - const Auth = require('../src/Auth.js').Auth; + const Auth = require('../lib/Auth.js').Auth; describe('getUserRoles', () => { let auth; diff --git a/spec/AuthenticationAdapters.spec.js b/spec/AuthenticationAdapters.spec.js index ad77d0b7c7..f7d1d645c1 100644 --- a/spec/AuthenticationAdapters.spec.js +++ b/spec/AuthenticationAdapters.spec.js @@ -1,13 +1,13 @@ const request = require('request'); -const Config = require("../src/Config"); -const defaultColumns = require('../src/Controllers/SchemaController').defaultColumns; -const authenticationLoader = require('../src/Adapters/Auth'); +const Config = require("../lib/Config"); +const defaultColumns = require('../lib/Controllers/SchemaController').defaultColumns; +const authenticationLoader = require('../lib/Adapters/Auth'); const path = require('path'); describe('AuthenticationProviders', function() { ["facebook", "facebookaccountkit", "github", "instagram", "google", "linkedin", "meetup", "twitter", "janrainengage", "janraincapture", "vkontakte"].map(function(providerName){ it("Should validate structure of " + providerName, (done) => { - const provider = require("../src/Adapters/Auth/" + providerName); + const provider = require("../lib/Adapters/Auth/" + providerName); jequal(typeof provider.validateAuthData, "function"); jequal(typeof provider.validateAppId, "function"); const authDataPromise = provider.validateAuthData({}, {}); @@ -301,7 +301,7 @@ describe('AuthenticationProviders', function() { }) }); - it('properly loads custom adapter module object', (done) => { + it('properly loads custom adapter module object (again)', (done) => { const authenticationHandler = authenticationLoader({ customAuthentication: { module: path.resolve('./spec/support/CustomAuthFunction.js'), options: { token: 'valid-token' }} }); diff --git a/spec/CLI.spec.js b/spec/CLI.spec.js index 066bd64455..36056fd1f5 100644 --- a/spec/CLI.spec.js +++ b/spec/CLI.spec.js @@ -1,7 +1,7 @@ 'use strict'; -import commander from '../src/cli/utils/commander'; -import definitions from '../src/cli/definitions/parse-server'; -import liveQueryDefinitions from '../src/cli/definitions/parse-live-query-server'; +const commander = require('../lib/cli/utils/commander').default; +const definitions = require('../lib/cli/definitions/parse-server').default; +const liveQueryDefinitions = require('../lib/cli/definitions/parse-live-query-server').default; const testDefinitions = { 'arg0': 'PROGRAM_ARG_0', @@ -173,7 +173,7 @@ describe('LiveQuery definitions', () => { if (typeof definition.env !== 'undefined') { expect(typeof definition.env).toBe('string'); } - expect(typeof definition.help).toBe('string'); + expect(typeof definition.help).toBe('string', `help for ${key} should be a string`); if (typeof definition.required !== 'undefined') { expect(typeof definition.required).toBe('boolean'); } diff --git a/spec/CacheController.spec.js b/spec/CacheController.spec.js index 219dc89dd8..ec37ae6b2b 100644 --- a/spec/CacheController.spec.js +++ b/spec/CacheController.spec.js @@ -1,4 +1,4 @@ -const CacheController = require('../src/Controllers/CacheController.js').default; +const CacheController = require('../lib/Controllers/CacheController.js').default; describe('CacheController', function() { let FakeCacheAdapter; diff --git a/spec/Client.spec.js b/spec/Client.spec.js index 403c8e5aef..b95b673d6f 100644 --- a/spec/Client.spec.js +++ b/spec/Client.spec.js @@ -1,5 +1,5 @@ -const Client = require('../src/LiveQuery/Client').Client; -const ParseWebSocket = require('../src/LiveQuery/ParseWebSocketServer').ParseWebSocket; +const Client = require('../lib/LiveQuery/Client').Client; +const ParseWebSocket = require('../lib/LiveQuery/ParseWebSocketServer').ParseWebSocket; describe('Client', function() { it('can be initialized', function() { diff --git a/spec/ClientSDK.spec.js b/spec/ClientSDK.spec.js index 90766a8590..3825681748 100644 --- a/spec/ClientSDK.spec.js +++ b/spec/ClientSDK.spec.js @@ -1,4 +1,4 @@ -const ClientSDK = require('../src/ClientSDK'); +const ClientSDK = require('../lib/ClientSDK'); describe('ClientSDK', () => { it('should properly parse the SDK versions', () => { diff --git a/spec/CloudCode.spec.js b/spec/CloudCode.spec.js index 98e52e056e..978aa9c3aa 100644 --- a/spec/CloudCode.spec.js +++ b/spec/CloudCode.spec.js @@ -1,7 +1,7 @@ "use strict" const Parse = require("parse/node"); const rp = require('request-promise'); -const InMemoryCacheAdapter = require('../src/Adapters/Cache/InMemoryCacheAdapter').InMemoryCacheAdapter; +const InMemoryCacheAdapter = require('../lib/Adapters/Cache/InMemoryCacheAdapter').InMemoryCacheAdapter; describe('Cloud Code', () => { it('can load absolute cloud code file', done => { @@ -983,7 +983,7 @@ describe('Cloud Code', () => { TODO: fix for Postgres trying to delete a field that doesn't exists doesn't play nice */ - it_exclude_dbs(['postgres'])('should fully delete objects when using `unset` with beforeSave (regression test for #1840)', done => { + it_exclude_dbs(['postgres'])('should fully delete objects when using `unset` and `set` with beforeSave (regression test for #1840)', done => { const TestObject = Parse.Object.extend('TestObject'); const BeforeSaveObject = Parse.Object.extend('BeforeSaveChanged'); diff --git a/spec/CloudCodeLogger.spec.js b/spec/CloudCodeLogger.spec.js index 7289136169..ce4c59bc35 100644 --- a/spec/CloudCodeLogger.spec.js +++ b/spec/CloudCodeLogger.spec.js @@ -1,5 +1,5 @@ -const LoggerController = require('../src/Controllers/LoggerController').LoggerController; -const WinstonLoggerAdapter = require('../src/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; +const LoggerController = require('../lib/Controllers/LoggerController').LoggerController; +const WinstonLoggerAdapter = require('../lib/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; const fs = require('fs'); const loremFile = __dirname + '/support/lorem.txt'; diff --git a/spec/DatabaseController.spec.js b/spec/DatabaseController.spec.js index 43e85ccf87..fe9ee8069e 100644 --- a/spec/DatabaseController.spec.js +++ b/spec/DatabaseController.spec.js @@ -1,4 +1,4 @@ -const DatabaseController = require('../src/Controllers/DatabaseController.js'); +const DatabaseController = require('../lib/Controllers/DatabaseController.js'); const validateQuery = DatabaseController._validateQuery; describe('DatabaseController', function() { diff --git a/spec/EmailVerificationToken.spec.js b/spec/EmailVerificationToken.spec.js index b6e05a29e2..0585831aee 100644 --- a/spec/EmailVerificationToken.spec.js +++ b/spec/EmailVerificationToken.spec.js @@ -2,7 +2,7 @@ const request = require('request'); const requestp = require('request-promise'); -const Config = require('../src/Config'); +const Config = require('../lib/Config'); describe("Email Verification Token Expiration: ", () => { diff --git a/spec/EnableExpressErrorHandler.spec.js b/spec/EnableExpressErrorHandler.spec.js new file mode 100644 index 0000000000..648e986c2a --- /dev/null +++ b/spec/EnableExpressErrorHandler.spec.js @@ -0,0 +1,66 @@ +const ParseServer = require("../lib/index"); +const express = require('express'); +const rp = require('request-promise'); + +describe('Enable express error handler', () => { + + it('should call the default handler in case of error, like updating a non existing object', done => { + const serverUrl = "http://localhost:12667/parse" + const appId = "anOtherTestApp"; + const masterKey = "anOtherTestMasterKey"; + let server; + + let lastError; + + const parseServer = ParseServer.ParseServer(Object.assign({}, + defaultConfiguration, { + appId: appId, + masterKey: masterKey, + serverURL: serverUrl, + enableExpressErrorHandler: true, + __indexBuildCompletionCallbackForTests: promise => { + promise.then(() => { + expect(Parse.applicationId).toEqual("anOtherTestApp"); + const app = express(); + app.use('/parse', parseServer); + + server = app.listen(12667); + + app.use(function (err, req, res, next) { + next; + lastError = err; + }) + + rp({ + method: 'PUT', + uri: serverUrl + '/classes/AnyClass/nonExistingId', + headers: { + 'X-Parse-Application-Id': appId, + 'X-Parse-Master-Key': masterKey + }, + body: { someField: "blablabla" }, + json: true + }).then(() => { + fail('Should throw error'); + }).catch(e => { + expect(e).toBeDefined(); + const reqError = e.error; + expect(reqError).toBeDefined(); + expect(lastError).toBeDefined(); + + expect(lastError.code).toEqual(101) + expect(lastError.message).toEqual('Object not found.') + + expect(lastError.code).toEqual(reqError.code); + expect(lastError.message).toEqual(reqError.error); + }).then(() => { + server.close(done); + }); + }) + } + } + )); + }); + +}); + diff --git a/spec/EnableSingleSchemaCache.spec.js b/spec/EnableSingleSchemaCache.spec.js index 2638c56e46..386d186a3e 100644 --- a/spec/EnableSingleSchemaCache.spec.js +++ b/spec/EnableSingleSchemaCache.spec.js @@ -1,6 +1,6 @@ -const auth = require('../src/Auth'); -const Config = require('../src/Config'); -const rest = require('../src/rest'); +const auth = require('../lib/Auth'); +const Config = require('../lib/Config'); +const rest = require('../lib/rest'); describe('Enable single schema cache', () => { beforeEach((done) => { diff --git a/spec/EventEmitterPubSub.spec.js b/spec/EventEmitterPubSub.spec.js index 2ac94e4f88..99b4f51df4 100644 --- a/spec/EventEmitterPubSub.spec.js +++ b/spec/EventEmitterPubSub.spec.js @@ -1,4 +1,4 @@ -const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; +const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; describe('EventEmitterPubSub', function() { it('can publish and subscribe', function() { diff --git a/spec/FilesController.spec.js b/spec/FilesController.spec.js index 3cb5f3e3fa..21432793a6 100644 --- a/spec/FilesController.spec.js +++ b/spec/FilesController.spec.js @@ -1,8 +1,8 @@ -const LoggerController = require('../src/Controllers/LoggerController').LoggerController; -const WinstonLoggerAdapter = require('../src/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; -const GridStoreAdapter = require("../src/Adapters/Files/GridStoreAdapter").GridStoreAdapter; -const Config = require("../src/Config"); -const FilesController = require('../src/Controllers/FilesController').default; +const LoggerController = require('../lib/Controllers/LoggerController').LoggerController; +const WinstonLoggerAdapter = require('../lib/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; +const GridStoreAdapter = require("../lib/Adapters/Files/GridStoreAdapter").GridStoreAdapter; +const Config = require("../lib/Config"); +const FilesController = require('../lib/Controllers/FilesController').default; const mockAdapter = { createFile: () => { @@ -14,13 +14,13 @@ const mockAdapter = { } // Small additional tests to improve overall coverage -describe("FilesController",() =>{ +describe("FilesController", () => { it("should properly expand objects", (done) => { const config = Config.get(Parse.applicationId); const gridStoreAdapter = new GridStoreAdapter('mongodb://localhost:27017/parse'); const filesController = new FilesController(gridStoreAdapter) - const result = filesController.expandFilesInObject(config, function(){}); + const result = filesController.expandFilesInObject(config, function () { }); expect(result).toBeUndefined(); @@ -43,7 +43,7 @@ describe("FilesController",() =>{ reconfigureServer({ filesAdapter: mockAdapter }) .then(() => new Promise(resolve => setTimeout(resolve, 1000))) - .then(() => new Parse.File("yolo.txt", [1,2,3], "text/plain").save()) + .then(() => new Parse.File("yolo.txt", [1, 2, 3], "text/plain").save()) .then( () => done.fail('should not succeed'), () => setImmediate(() => Parse.Promise.as('done')) @@ -62,4 +62,40 @@ describe("FilesController",() =>{ done(); }); }); + + it("should add a unique hash to the file name when the preserveFileName option is false", (done) => { + + const config = Config.get(Parse.applicationId) + const gridStoreAdapter = new GridStoreAdapter('mongodb://localhost:27017/parse') + spyOn(gridStoreAdapter, 'createFile') + gridStoreAdapter.createFile.and.returnValue(Promise.resolve()) + const fileName = 'randomFileName.pdf' + const regexEscapedFileName = fileName.replace(/\./g, "\\$&") + const filesController = new FilesController(gridStoreAdapter, null, { preserveFileName: false }) + + filesController.createFile(config, fileName) + + expect(gridStoreAdapter.createFile).toHaveBeenCalledTimes(1) + expect(gridStoreAdapter.createFile.calls.mostRecent().args[0]).toMatch(`^.{32}_${regexEscapedFileName}$`) + + done(); + }); + + it("should not add a unique hash to the file name when the preserveFileName option is true", (done) => { + + const config = Config.get(Parse.applicationId) + const gridStoreAdapter = new GridStoreAdapter('mongodb://localhost:27017/parse') + spyOn(gridStoreAdapter, 'createFile') + gridStoreAdapter.createFile.and.returnValue(Promise.resolve()) + const fileName = 'randomFileName.pdf' + const filesController = new FilesController(gridStoreAdapter, null, { preserveFileName: true }) + + filesController.createFile(config, fileName) + + expect(gridStoreAdapter.createFile).toHaveBeenCalledTimes(1) + expect(gridStoreAdapter.createFile.calls.mostRecent().args[0]).toEqual(fileName) + + done(); + }); + }); diff --git a/spec/GridStoreAdapter.js b/spec/GridStoreAdapter.js index 2cc16fdbbd..d408430dfd 100644 --- a/spec/GridStoreAdapter.js +++ b/spec/GridStoreAdapter.js @@ -1,9 +1,9 @@ const MongoClient = require("mongodb").MongoClient; const GridStore = require("mongodb").GridStore; -const GridStoreAdapter = require("../src/Adapters/Files/GridStoreAdapter").GridStoreAdapter; -const Config = require("../src/Config"); -const FilesController = require('../src/Controllers/FilesController').default; +const GridStoreAdapter = require("../lib/Adapters/Files/GridStoreAdapter").GridStoreAdapter; +const Config = require("../lib/Config"); +const FilesController = require('../lib/Controllers/FilesController').default; // Small additional tests to improve overall coverage diff --git a/spec/HTTPRequest.spec.js b/spec/HTTPRequest.spec.js index 5ea67f2619..7ccabd1d01 100644 --- a/spec/HTTPRequest.spec.js +++ b/spec/HTTPRequest.spec.js @@ -1,42 +1,52 @@ 'use strict'; -const httpRequest = require("../src/cloud-code/httpRequest"), - HTTPResponse = require('../src/cloud-code/HTTPResponse').default, +const httpRequest = require("../lib/cloud-code/httpRequest"), + HTTPResponse = require('../lib/cloud-code/HTTPResponse').default, bodyParser = require('body-parser'), express = require("express"); const port = 13371; const httpRequestServer = "http://localhost:" + port; -const app = express(); -app.use(bodyParser.json({ 'type': '*/*' })); -app.get("/hello", function(req, res){ - res.json({response: "OK"}); -}); - -app.get("/404", function(req, res){ - res.status(404); - res.send("NO"); -}); +function startServer(done) { + const app = express(); + app.use(bodyParser.json({ 'type': '*/*' })); + app.get("/hello", function(req, res){ + res.json({response: "OK"}); + }); -app.get("/301", function(req, res){ - res.status(301); - res.location("/hello"); - res.send(); -}); + app.get("/404", function(req, res){ + res.status(404); + res.send("NO"); + }); -app.post('/echo', function(req, res){ - res.json(req.body); -}); + app.get("/301", function(req, res){ + res.status(301); + res.location("/hello"); + res.send(); + }); -app.get('/qs', function(req, res){ - res.json(req.query); -}); + app.post('/echo', function(req, res){ + res.json(req.body); + }); -app.listen(13371); + app.get('/qs', function(req, res){ + res.json(req.query); + }); + return app.listen(13371, undefined, done); +} describe("httpRequest", () => { + let server; + beforeAll((done) => { + server = startServer(done); + }); + + afterAll((done) => { + server.close(done); + }); + it("should do /hello", (done) => { httpRequest({ url: httpRequestServer + "/hello" @@ -122,21 +132,6 @@ describe("httpRequest", () => { }); }) - it("should fail on 404", (done) => { - httpRequest({ - url: httpRequestServer + "/404", - }).then(function(){ - fail("should not succeed"); - done(); - }, function(httpResponse){ - expect(httpResponse.status).toBe(404); - expect(httpResponse.buffer).toEqual(new Buffer('NO')); - expect(httpResponse.text).toEqual('NO'); - expect(httpResponse.data).toBe(undefined); - done(); - }) - }) - it("should post on echo", (done) => { let calls = 0; httpRequest({ @@ -204,6 +199,7 @@ describe("httpRequest", () => { it("should fail gracefully", (done) => { httpRequest({ url: "http://not a good url", + timeout: 10, success: function() { fail("should not succeed"); done(); diff --git a/spec/InMemoryCache.spec.js b/spec/InMemoryCache.spec.js index c5c7cd3810..c8f015497a 100644 --- a/spec/InMemoryCache.spec.js +++ b/spec/InMemoryCache.spec.js @@ -1,4 +1,4 @@ -const InMemoryCache = require('../src/Adapters/Cache/InMemoryCache').default; +const InMemoryCache = require('../lib/Adapters/Cache/InMemoryCache').default; describe('InMemoryCache', function() { @@ -28,7 +28,7 @@ describe('InMemoryCache', function() { let value = cache.get(KEY); expect(value).toEqual(VALUE); - wait(BASE_TTL.ttl * 2).then(() => { + wait(BASE_TTL.ttl * 10).then(() => { value = cache.get(KEY) expect(value).toEqual(null); done(); diff --git a/spec/InMemoryCacheAdapter.spec.js b/spec/InMemoryCacheAdapter.spec.js index ac041a7533..9bf49f087c 100644 --- a/spec/InMemoryCacheAdapter.spec.js +++ b/spec/InMemoryCacheAdapter.spec.js @@ -1,4 +1,4 @@ -const InMemoryCacheAdapter = require('../src/Adapters/Cache/InMemoryCacheAdapter').default; +const InMemoryCacheAdapter = require('../lib/Adapters/Cache/InMemoryCacheAdapter').default; describe('InMemoryCacheAdapter', function() { const KEY = 'hello'; diff --git a/spec/InstallationsRouter.spec.js b/spec/InstallationsRouter.spec.js index 47dd6df290..7337096735 100644 --- a/spec/InstallationsRouter.spec.js +++ b/spec/InstallationsRouter.spec.js @@ -1,7 +1,7 @@ -const auth = require('../src/Auth'); -const Config = require('../src/Config'); -const rest = require('../src/rest'); -const InstallationsRouter = require('../src/Routers/InstallationsRouter').InstallationsRouter; +const auth = require('../lib/Auth'); +const Config = require('../lib/Config'); +const rest = require('../lib/rest'); +const InstallationsRouter = require('../lib/Routers/InstallationsRouter').InstallationsRouter; describe('InstallationsRouter', () => { it('uses find condition from request.body', (done) => { diff --git a/spec/JobSchedule.spec.js b/spec/JobSchedule.spec.js index bd8ca3070b..def48e180f 100644 --- a/spec/JobSchedule.spec.js +++ b/spec/JobSchedule.spec.js @@ -50,11 +50,11 @@ describe('JobSchedule', () => { rp.put(Parse.serverURL + '/cloud_code/jobs/jobId', defaultOptions).then(done.fail, () => done()); }); - it('should reject access when not using masterKey (PUT /jobs/id)', (done) => { + it('should reject access when not using masterKey (DELETE /jobs/id)', (done) => { rp.del(Parse.serverURL + '/cloud_code/jobs/jobId', defaultOptions).then(done.fail, () => done()); }); - it('should allow access when using masterKey (/jobs)', (done) => { + it('should allow access when using masterKey (GET /jobs)', (done) => { rp.get(Parse.serverURL + '/cloud_code/jobs', masterKeyOptions).then(done, done.fail); }); diff --git a/spec/Logger.spec.js b/spec/Logger.spec.js index ee35e353fe..bd268fa78e 100644 --- a/spec/Logger.spec.js +++ b/spec/Logger.spec.js @@ -1,4 +1,4 @@ -const logging = require('../src/Adapters/Logger/WinstonLogger'); +const logging = require('../lib/Adapters/Logger/WinstonLogger'); const winston = require('winston'); class TestTransport extends winston.Transport { diff --git a/spec/LoggerController.spec.js b/spec/LoggerController.spec.js index 4a8e63f4d3..36306b662a 100644 --- a/spec/LoggerController.spec.js +++ b/spec/LoggerController.spec.js @@ -1,8 +1,8 @@ -const LoggerController = require('../src/Controllers/LoggerController').LoggerController; -const WinstonLoggerAdapter = require('../src/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; +const LoggerController = require('../lib/Controllers/LoggerController').LoggerController; +const WinstonLoggerAdapter = require('../lib/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; describe('LoggerController', () => { - it('can check process a query without throwing', (done) => { + it('can process an empty query without throwing', (done) => { // Make mock request const query = {}; @@ -37,7 +37,7 @@ describe('LoggerController', () => { done(); }); - it('can process a query without throwing', (done) => { + it('can process an ascending query without throwing', (done) => { // Make mock request const query = { from: "2016-01-01Z00:00:00", @@ -58,7 +58,7 @@ describe('LoggerController', () => { done(); }); - it('can check process a query without throwing', (done) => { + it('can process a descending query without throwing', (done) => { // Make mock request const query = { from: "2016-01-01", diff --git a/spec/LogsRouter.spec.js b/spec/LogsRouter.spec.js index 65c8b62f5b..38de9ac318 100644 --- a/spec/LogsRouter.spec.js +++ b/spec/LogsRouter.spec.js @@ -1,9 +1,9 @@ 'use strict'; const request = require('request'); -const LogsRouter = require('../src/Routers/LogsRouter').LogsRouter; -const LoggerController = require('../src/Controllers/LoggerController').LoggerController; -const WinstonLoggerAdapter = require('../src/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; +const LogsRouter = require('../lib/Routers/LogsRouter').LogsRouter; +const LoggerController = require('../lib/Controllers/LoggerController').LoggerController; +const WinstonLoggerAdapter = require('../lib/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; const loggerController = new LoggerController(new WinstonLoggerAdapter()); diff --git a/spec/Middlewares.spec.js b/spec/Middlewares.spec.js index 0b1ea593f3..32e44a3cc8 100644 --- a/spec/Middlewares.spec.js +++ b/spec/Middlewares.spec.js @@ -1,5 +1,5 @@ -const middlewares = require('../src/middlewares'); -const AppCache = require('../src/cache').AppCache; +const middlewares = require('../lib/middlewares'); +const AppCache = require('../lib/cache').AppCache; describe('middlewares', () => { @@ -290,4 +290,16 @@ describe('middlewares', () => { middlewares.handleParseHeaders(fakeReq, fakeRes); expect(fakeRes.status).toHaveBeenCalledWith(403); }); + + it('should properly expose the headers', () => { + const headers = {}; + const res = { + header: (key, value) => { + headers[key] = value + } + }; + middlewares.allowCrossDomain({}, res, () => {}); + expect(Object.keys(headers).length).toBe(4); + expect(headers['Access-Control-Expose-Headers']).toBe('X-Parse-Job-Status-Id, X-Parse-Push-Status-Id'); + }); }); diff --git a/spec/MongoSchemaCollectionAdapter.spec.js b/spec/MongoSchemaCollectionAdapter.spec.js index f5f75442f6..fe3d842a53 100644 --- a/spec/MongoSchemaCollectionAdapter.spec.js +++ b/spec/MongoSchemaCollectionAdapter.spec.js @@ -1,6 +1,6 @@ 'use strict'; -const MongoSchemaCollection = require('../src/Adapters/Storage/Mongo/MongoSchemaCollection').default; +const MongoSchemaCollection = require('../lib/Adapters/Storage/Mongo/MongoSchemaCollection').default; describe('MongoSchemaCollection', () => { it('can transform legacy _client_permissions keys to parse format', done => { diff --git a/spec/MongoStorageAdapter.spec.js b/spec/MongoStorageAdapter.spec.js index b263f70dad..d46c925308 100644 --- a/spec/MongoStorageAdapter.spec.js +++ b/spec/MongoStorageAdapter.spec.js @@ -1,6 +1,6 @@ 'use strict'; -import MongoStorageAdapter from '../src/Adapters/Storage/Mongo/MongoStorageAdapter'; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; const { MongoClient } = require('mongodb'); const databaseURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase'; @@ -61,7 +61,7 @@ describe_only_db('mongo')('MongoStorageAdapter', () => { }); it('find succeeds when query is within maxTimeMS', (done) => { - const maxTimeMS = 250; + const maxTimeMS = 2500; const adapter = new MongoStorageAdapter({ uri: databaseURI, mongoOptions: { maxTimeMS }, @@ -90,8 +90,8 @@ describe_only_db('mongo')('MongoStorageAdapter', () => { }, (err) => { expect(err.name).toEqual('MongoError'); - expect(err.code).toEqual(50); - expect(err.message).toEqual('operation exceeded time limit'); + expect(err.code).toEqual(96); + expect(err.message).toContain('operation exceeded time limit'); done(); } ); diff --git a/spec/MongoTransform.spec.js b/spec/MongoTransform.spec.js index 5489d95223..c38346c123 100644 --- a/spec/MongoTransform.spec.js +++ b/spec/MongoTransform.spec.js @@ -1,7 +1,7 @@ // These tests are unit tests designed to only test transform.js. "use strict"; -const transform = require('../src/Adapters/Storage/Mongo/MongoTransform'); +const transform = require('../lib/Adapters/Storage/Mongo/MongoTransform'); const dd = require('deep-diff'); const mongodb = require('mongodb'); @@ -24,7 +24,7 @@ describe('parseObjectToMongoObjectForCreate', () => { done(); }); - it('built-in timestamps', (done) => { + it('built-in timestamps with date', (done) => { const input = { createdAt: "2015-10-06T21:24:50.332Z", updatedAt: "2015-10-06T21:24:50.332Z" @@ -353,6 +353,41 @@ describe('parseObjectToMongoObjectForCreate', () => { expect(output.ts.iso).toEqual('2017-01-18T00:00:00.000Z'); done(); }); + + it('$regex in $all list', (done) => { + const input = { + arrayField: {'$all': [{$regex: '^\\Qone\\E'}, {$regex: '^\\Qtwo\\E'}, {$regex: '^\\Qthree\\E'}]}, + }; + const outputValue = { + arrayField: {'$all': [/^\Qone\E/, /^\Qtwo\E/, /^\Qthree\E/]}, + }; + + const output = transform.transformWhere(null, input); + jequal(outputValue.arrayField, output.arrayField); + done(); + }); + + it('$regex in $all list must be { $regex: "string" }', (done) => { + const input = { + arrayField: {'$all': [{$regex: 1}]}, + }; + + expect(() => { + transform.transformWhere(null, input) + }).toThrow(); + done(); + }); + + it('all values in $all must be $regex (start with string) or non $regex (start with string)', (done) => { + const input = { + arrayField: {'$all': [{$regex: '^\\Qone\\E'}, {$unknown: '^\\Qtwo\\E'}]}, + }; + + expect(() => { + transform.transformWhere(null, input) + }).toThrow(); + done(); + }); }); describe('transformUpdate', () => { diff --git a/spec/NullCacheAdapter.spec.js b/spec/NullCacheAdapter.spec.js index d1d6b0a91e..04d4cdcd68 100644 --- a/spec/NullCacheAdapter.spec.js +++ b/spec/NullCacheAdapter.spec.js @@ -1,4 +1,4 @@ -const NullCacheAdapter = require('../src/Adapters/Cache/NullCacheAdapter').default; +const NullCacheAdapter = require('../lib/Adapters/Cache/NullCacheAdapter').default; describe('NullCacheAdapter', function() { const KEY = 'hello'; diff --git a/spec/OAuth1.spec.js b/spec/OAuth1.spec.js index 31b683163c..ed74bfb9e8 100644 --- a/spec/OAuth1.spec.js +++ b/spec/OAuth1.spec.js @@ -1,4 +1,4 @@ -const OAuth = require("../src/Adapters/Auth/OAuth1Client"); +const OAuth = require("../lib/Adapters/Auth/OAuth1Client"); describe('OAuth', function() { it("Nonce should have right length", (done) => { diff --git a/spec/ParseACL.spec.js b/spec/ParseACL.spec.js index 8398ccba94..3069bd12b5 100644 --- a/spec/ParseACL.spec.js +++ b/spec/ParseACL.spec.js @@ -1,8 +1,8 @@ // This is a port of the test suite: // hungry/js/test/parse_acl_test.js -const rest = require('../src/rest'); -const Config = require('../src/Config'); -const auth = require('../src/Auth'); +const rest = require('../lib/rest'); +const Config = require('../lib/Config'); +const auth = require('../lib/Auth'); describe('Parse.ACL', () => { it("acl must be valid", (done) => { diff --git a/spec/ParseAPI.spec.js b/spec/ParseAPI.spec.js index de16ebb737..5d3861fe42 100644 --- a/spec/ParseAPI.spec.js +++ b/spec/ParseAPI.spec.js @@ -5,9 +5,9 @@ const request = require('request'); const rp = require('request-promise'); const Parse = require("parse/node"); -const Config = require('../src/Config'); -const SchemaController = require('../src/Controllers/SchemaController'); -const TestUtils = require('../src/TestUtils'); +const Config = require('../lib/Config'); +const SchemaController = require('../lib/Controllers/SchemaController'); +const TestUtils = require('../lib/TestUtils'); const userSchema = SchemaController.convertSchemaToAdapterSchema({ className: '_User', fields: Object.assign({}, SchemaController.defaultColumns._Default, SchemaController.defaultColumns._User) }); @@ -975,6 +975,25 @@ describe('miscellaneous', function() { }); }); + it('test beforeDelete with locked down ACL', async () => { + let called = false; + Parse.Cloud.beforeDelete('GameScore', (req, res) => { + called = true; + res.success(); + }); + const object = new Parse.Object('GameScore'); + object.setACL(new Parse.ACL()); + await object.save(); + const objects = await new Parse.Query('GameScore').find(); + expect(objects.length).toBe(0); + try { + await object.destroy(); + } catch(e) { + expect(e.code).toBe(Parse.Error.OBJECT_NOT_FOUND); + } + expect(called).toBe(false); + }); + it('test cloud function query parameters', (done) => { Parse.Cloud.define('echoParams', (req, res) => { res.success(req.params); @@ -1493,6 +1512,11 @@ describe('miscellaneous', function() { }); }); + it('purge empty class', (done) => { + const testSchema = new Parse.Schema('UnknownClass'); + testSchema.purge().then(done).catch(done.fail); + }); + it('should not update schema beforeSave #2672', (done) => { Parse.Cloud.beforeSave('MyObject', (request, response) => { if (request.object.get('secret')) { diff --git a/spec/ParseCloudCodePublisher.spec.js b/spec/ParseCloudCodePublisher.spec.js index 00e6a87943..1c242d9d7d 100644 --- a/spec/ParseCloudCodePublisher.spec.js +++ b/spec/ParseCloudCodePublisher.spec.js @@ -1,4 +1,4 @@ -const ParseCloudCodePublisher = require('../src/LiveQuery/ParseCloudCodePublisher').ParseCloudCodePublisher; +const ParseCloudCodePublisher = require('../lib/LiveQuery/ParseCloudCodePublisher').ParseCloudCodePublisher; const Parse = require('parse/node'); describe('ParseCloudCodePublisher', function() { @@ -14,7 +14,7 @@ describe('ParseCloudCodePublisher', function() { on: jasmine.createSpy('on') }) }; - jasmine.mockLibrary('../src/LiveQuery/ParsePubSub', 'ParsePubSub', mockParsePubSub); + jasmine.mockLibrary('../lib/LiveQuery/ParsePubSub', 'ParsePubSub', mockParsePubSub); done(); }); @@ -22,7 +22,7 @@ describe('ParseCloudCodePublisher', function() { const config = {} new ParseCloudCodePublisher(config); - const ParsePubSub = require('../src/LiveQuery/ParsePubSub').ParsePubSub; + const ParsePubSub = require('../lib/LiveQuery/ParsePubSub').ParsePubSub; expect(ParsePubSub.createPublisher).toHaveBeenCalledWith(config); }); @@ -64,6 +64,6 @@ describe('ParseCloudCodePublisher', function() { }); afterEach(function(){ - jasmine.restoreLibrary('../src/LiveQuery/ParsePubSub', 'ParsePubSub'); + jasmine.restoreLibrary('../lib/LiveQuery/ParsePubSub', 'ParsePubSub'); }); }); diff --git a/spec/ParseFile.spec.js b/spec/ParseFile.spec.js index 9f19a87119..d5f7d38c7f 100644 --- a/spec/ParseFile.spec.js +++ b/spec/ParseFile.spec.js @@ -632,24 +632,6 @@ describe('Parse.File testing', () => { }); }); - it('fails to upload without a file name', done => { - const headers = { - 'Content-Type': 'application/octet-stream', - 'X-Parse-Application-Id': 'test', - 'X-Parse-REST-API-Key': 'rest' - }; - request.post({ - headers: headers, - url: 'http://localhost:8378/1/files/', - body: 'yolo', - }, (error, response, body) => { - expect(error).toBe(null); - expect(response.statusCode).toBe(400); - expect(body).toEqual('{"code":122,"error":"Filename not provided."}'); - done(); - }); - }); - it('fails to delete an unkown file', done => { const headers = { 'Content-Type': 'application/octet-stream', diff --git a/spec/ParseGeoPoint.spec.js b/spec/ParseGeoPoint.spec.js index 66915c7f80..ec6ec79295 100644 --- a/spec/ParseGeoPoint.spec.js +++ b/spec/ParseGeoPoint.spec.js @@ -496,6 +496,116 @@ describe('Parse.GeoPoint testing', () => { }, done.fail); }); + it('supports withinPolygon Polygon object', (done) => { + const inbound = new Parse.GeoPoint(1.5, 1.5); + const onbound = new Parse.GeoPoint(10, 10); + const outbound = new Parse.GeoPoint(20, 20); + const obj1 = new Parse.Object('Polygon', {location: inbound}); + const obj2 = new Parse.Object('Polygon', {location: onbound}); + const obj3 = new Parse.Object('Polygon', {location: outbound}); + const polygon = { + __type: 'Polygon', + coordinates: [ + [0, 0], + [10, 0], + [10, 10], + [0, 10], + [0, 0] + ] + } + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + const where = { + location: { + $geoWithin: { + $polygon: polygon + } + } + }; + return rp.post({ + url: Parse.serverURL + '/classes/Polygon', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((resp) => { + expect(resp.results.length).toBe(2); + done(); + }, done.fail); + }); + + it('invalid Polygon object withinPolygon', (done) => { + const point = new Parse.GeoPoint(1.5, 1.5); + const obj = new Parse.Object('Polygon', {location: point}); + const polygon = { + __type: 'Polygon', + coordinates: [ + [0, 0], + [10, 0], + ] + } + obj.save().then(() => { + const where = { + location: { + $geoWithin: { + $polygon: polygon + } + } + }; + return rp.post({ + url: Parse.serverURL + '/classes/Polygon', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((resp) => { + fail(`no request should succeed: ${JSON.stringify(resp)}`); + done(); + }).catch((err) => { + expect(err.error.code).toEqual(Parse.Error.INVALID_JSON); + done(); + }); + }); + + it('out of bounds Polygon object withinPolygon', (done) => { + const point = new Parse.GeoPoint(1.5, 1.5); + const obj = new Parse.Object('Polygon', {location: point}); + const polygon = { + __type: 'Polygon', + coordinates: [ + [0, 0], + [181, 0], + [0, 10] + ] + } + obj.save().then(() => { + const where = { + location: { + $geoWithin: { + $polygon: polygon + } + } + }; + return rp.post({ + url: Parse.serverURL + '/classes/Polygon', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((resp) => { + fail(`no request should succeed: ${JSON.stringify(resp)}`); + done(); + }).catch((err) => { + expect(err.error.code).toEqual(1); + done(); + }); + }); + it('invalid input withinPolygon', (done) => { const point = new Parse.GeoPoint(1.5, 1.5); const obj = new Parse.Object('Polygon', {location: point}); diff --git a/spec/ParseGlobalConfig.spec.js b/spec/ParseGlobalConfig.spec.js index 46f9c0785c..2e1032a670 100644 --- a/spec/ParseGlobalConfig.spec.js +++ b/spec/ParseGlobalConfig.spec.js @@ -1,7 +1,7 @@ 'use strict'; const request = require('request'); -const Config = require('../src/Config'); +const Config = require('../lib/Config'); describe('a GlobalConfig', () => { beforeEach(done => { diff --git a/spec/ParseHooks.spec.js b/spec/ParseHooks.spec.js index 86dcd8e600..5b8900395c 100644 --- a/spec/ParseHooks.spec.js +++ b/spec/ParseHooks.spec.js @@ -1,20 +1,28 @@ "use strict"; /* global describe, it, expect, fail, Parse */ const request = require('request'); -const triggers = require('../src/triggers'); -const HooksController = require('../src/Controllers/HooksController').default; +const triggers = require('../lib/triggers'); +const HooksController = require('../lib/Controllers/HooksController').default; const express = require("express"); const bodyParser = require('body-parser'); const port = 12345; const hookServerURL = "http://localhost:" + port; -const AppCache = require('../src/cache').AppCache; - -const app = express(); -app.use(bodyParser.json({ 'type': '*/*' })) -app.listen(12345); +const AppCache = require('../lib/cache').AppCache; describe('Hooks', () => { + let server; + let app; + beforeAll((done) => { + app = express(); + app.use(bodyParser.json({ 'type': '*/*' })) + server = app.listen(12345, undefined, done); + }); + + afterAll((done) => { + server.close(done); + }); + it("should have no hooks registered", (done) => { Parse.Hooks.getFunctions().then((res) => { expect(res.constructor).toBe(Array.prototype.constructor); @@ -328,7 +336,7 @@ describe('Hooks', () => { }); }); - it("should run the function on the test server", (done) => { + it("should run the function on the test server (error handling)", (done) => { app.post("/SomeFunctionError", function(req, res) { res.json({error: {code: 1337, error: "hacking that one!"}}); diff --git a/spec/ParseInstallation.spec.js b/spec/ParseInstallation.spec.js index 9102291bcc..853262087f 100644 --- a/spec/ParseInstallation.spec.js +++ b/spec/ParseInstallation.spec.js @@ -2,15 +2,15 @@ // These tests check the Installations functionality of the REST API. // Ported from installation_collection_test.go -const auth = require('../src/Auth'); -const Config = require('../src/Config'); +const auth = require('../lib/Auth'); +const Config = require('../lib/Config'); const Parse = require('parse/node').Parse; -const rest = require('../src/rest'); +const rest = require('../lib/rest'); const request = require("request"); let config; let database; -const defaultColumns = require('../src/Controllers/SchemaController').defaultColumns; +const defaultColumns = require('../lib/Controllers/SchemaController').defaultColumns; const delay = function delay(delay) { return new Promise(resolve => setTimeout(resolve, delay)); diff --git a/spec/ParseLiveQueryServer.spec.js b/spec/ParseLiveQueryServer.spec.js index 9f3477476a..6defef456d 100644 --- a/spec/ParseLiveQueryServer.spec.js +++ b/spec/ParseLiveQueryServer.spec.js @@ -1,6 +1,6 @@ const Parse = require('parse/node'); -const ParseLiveQueryServer = require('../src/LiveQuery/ParseLiveQueryServer').ParseLiveQueryServer; -const ParseServer = require('../src/ParseServer').default; +const ParseLiveQueryServer = require('../lib/LiveQuery/ParseLiveQueryServer').ParseLiveQueryServer; +const ParseServer = require('../lib/ParseServer').default; // Global mock info const queryHashValue = 'hash'; @@ -11,7 +11,7 @@ describe('ParseLiveQueryServer', function() { beforeEach(function(done) { // Mock ParseWebSocketServer const mockParseWebSocketServer = jasmine.createSpy('ParseWebSocketServer'); - jasmine.mockLibrary('../src/LiveQuery/ParseWebSocketServer', 'ParseWebSocketServer', mockParseWebSocketServer); + jasmine.mockLibrary('../lib/LiveQuery/ParseWebSocketServer', 'ParseWebSocketServer', mockParseWebSocketServer); // Mock Client const mockClient = function(id, socket, hasMasterKey) { this.pushConnect = jasmine.createSpy('pushConnect'); @@ -28,19 +28,19 @@ describe('ParseLiveQueryServer', function() { this.hasMasterKey = hasMasterKey; } mockClient.pushError = jasmine.createSpy('pushError'); - jasmine.mockLibrary('../src/LiveQuery/Client', 'Client', mockClient); + jasmine.mockLibrary('../lib/LiveQuery/Client', 'Client', mockClient); // Mock Subscription const mockSubscriotion = function() { this.addClientSubscription = jasmine.createSpy('addClientSubscription'); this.deleteClientSubscription = jasmine.createSpy('deleteClientSubscription'); } - jasmine.mockLibrary('../src/LiveQuery/Subscription', 'Subscription', mockSubscriotion); + jasmine.mockLibrary('../lib/LiveQuery/Subscription', 'Subscription', mockSubscriotion); // Mock queryHash const mockQueryHash = jasmine.createSpy('matchesQuery').and.returnValue(queryHashValue); - jasmine.mockLibrary('../src/LiveQuery/QueryTools', 'queryHash', mockQueryHash); + jasmine.mockLibrary('../lib/LiveQuery/QueryTools', 'queryHash', mockQueryHash); // Mock matchesQuery const mockMatchesQuery = jasmine.createSpy('matchesQuery').and.returnValue(true); - jasmine.mockLibrary('../src/LiveQuery/QueryTools', 'matchesQuery', mockMatchesQuery); + jasmine.mockLibrary('../lib/LiveQuery/QueryTools', 'matchesQuery', mockMatchesQuery); // Mock ParsePubSub const mockParsePubSub = { createPublisher: function() { @@ -56,7 +56,7 @@ describe('ParseLiveQueryServer', function() { } } }; - jasmine.mockLibrary('../src/LiveQuery/ParsePubSub', 'ParsePubSub', mockParsePubSub); + jasmine.mockLibrary('../lib/LiveQuery/ParsePubSub', 'ParsePubSub', mockParsePubSub); // Make mock SessionTokenCache const mockSessionTokenCache = function(){ this.getUserId = function(sessionToken){ @@ -69,7 +69,7 @@ describe('ParseLiveQueryServer', function() { return Parse.Promise.as(testUserId); }; }; - jasmine.mockLibrary('../src/LiveQuery/SessionTokenCache', 'SessionTokenCache', mockSessionTokenCache); + jasmine.mockLibrary('../lib/LiveQuery/SessionTokenCache', 'SessionTokenCache', mockSessionTokenCache); done(); }); @@ -102,46 +102,47 @@ describe('ParseLiveQueryServer', function() { parseLiveQueryServer.server.close(done); }); - it('can be initialized through ParseServer without liveQueryServerOptions', function(done) { - const parseServer = ParseServer.start({ - appId: 'hello', - masterKey: 'world', - port: 22345, - mountPath: '/1', - serverURL: 'http://localhost:12345/1', - liveQuery: { - classNames: ['Yolo'] - }, - startLiveQueryServer: true + describe_only_db('mongo')('initialization', () => { + it('can be initialized through ParseServer without liveQueryServerOptions', function(done) { + const parseServer = ParseServer.start({ + appId: 'hello', + masterKey: 'world', + port: 22345, + mountPath: '/1', + serverURL: 'http://localhost:12345/1', + liveQuery: { + classNames: ['Yolo'] + }, + startLiveQueryServer: true + }); + + expect(parseServer.liveQueryServer).not.toBeUndefined(); + expect(parseServer.liveQueryServer.server).toBe(parseServer.server); + parseServer.server.close(() => done()); }); - expect(parseServer.liveQueryServer).not.toBeUndefined(); - expect(parseServer.liveQueryServer.server).toBe(parseServer.server); - parseServer.server.close(() => done()); - }); + it('can be initialized through ParseServer with liveQueryServerOptions', function(done) { + const parseServer = ParseServer.start({ + appId: 'hello', + masterKey: 'world', + port: 22346, + mountPath: '/1', + serverURL: 'http://localhost:12345/1', + liveQuery: { + classNames: ['Yolo'] + }, + liveQueryServerOptions: { + port: 22347, + } + }); - it('can be initialized through ParseServer with liveQueryServerOptions', function(done) { - const parseServer = ParseServer.start({ - appId: 'hello', - masterKey: 'world', - port: 22346, - mountPath: '/1', - serverURL: 'http://localhost:12345/1', - liveQuery: { - classNames: ['Yolo'] - }, - liveQueryServerOptions: { - port: 22347, - } + expect(parseServer.liveQueryServer).not.toBeUndefined(); + expect(parseServer.liveQueryServer.server).not.toBe(parseServer.server); + parseServer.liveQueryServer.server.close(); + parseServer.server.close(() => done()); }); - - expect(parseServer.liveQueryServer).not.toBeUndefined(); - expect(parseServer.liveQueryServer.server).not.toBe(parseServer.server); - parseServer.liveQueryServer.server.close(); - parseServer.server.close(() => done()); }); - it('can handle connect command', function() { const parseLiveQueryServer = new ParseLiveQueryServer(10, 10, {}); const parseWebSocket = { @@ -166,7 +167,7 @@ describe('ParseLiveQueryServer', function() { }; parseLiveQueryServer._handleSubscribe(incompleteParseConn, {}); - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; expect(Client.pushError).toHaveBeenCalled(); }); @@ -272,7 +273,7 @@ describe('ParseLiveQueryServer', function() { }; parseLiveQueryServer._handleUnsubscribe(incompleteParseConn, {}); - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; expect(Client.pushError).toHaveBeenCalled(); }); @@ -283,7 +284,7 @@ describe('ParseLiveQueryServer', function() { }; parseLiveQueryServer._handleUnsubscribe(parseWebSocket, {}); - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; expect(Client.pushError).toHaveBeenCalled(); }); @@ -298,7 +299,7 @@ describe('ParseLiveQueryServer', function() { }; parseLiveQueryServer._handleUnsubscribe(parseWebSocket, {}); - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; expect(Client.pushError).toHaveBeenCalled(); }); @@ -444,7 +445,7 @@ describe('ParseLiveQueryServer', function() { const invalidRequest = '{}'; // Trigger message event parseWebSocket.emit('message', invalidRequest); - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; expect(Client.pushError).toHaveBeenCalled(); }); @@ -460,7 +461,7 @@ describe('ParseLiveQueryServer', function() { const unknownRequest = '{"op":"unknown"}'; // Trigger message event parseWebSocket.emit('message', unknownRequest); - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; expect(Client.pushError).toHaveBeenCalled(); }); @@ -787,7 +788,7 @@ describe('ParseLiveQueryServer', function() { const parseObject = {}; expect(parseLiveQueryServer._matchesSubscription(parseObject, subscription)).toBe(true); // Make sure matchesQuery is called - const matchesQuery = require('../src/LiveQuery/QueryTools').matchesQuery; + const matchesQuery = require('../lib/LiveQuery/QueryTools').matchesQuery; expect(matchesQuery).toHaveBeenCalledWith(parseObject, subscription.query); }); @@ -1208,18 +1209,18 @@ describe('ParseLiveQueryServer', function() { }); afterEach(function(){ - jasmine.restoreLibrary('../src/LiveQuery/ParseWebSocketServer', 'ParseWebSocketServer'); - jasmine.restoreLibrary('../src/LiveQuery/Client', 'Client'); - jasmine.restoreLibrary('../src/LiveQuery/Subscription', 'Subscription'); - jasmine.restoreLibrary('../src/LiveQuery/QueryTools', 'queryHash'); - jasmine.restoreLibrary('../src/LiveQuery/QueryTools', 'matchesQuery'); - jasmine.restoreLibrary('../src/LiveQuery/ParsePubSub', 'ParsePubSub'); - jasmine.restoreLibrary('../src/LiveQuery/SessionTokenCache', 'SessionTokenCache'); + jasmine.restoreLibrary('../lib/LiveQuery/ParseWebSocketServer', 'ParseWebSocketServer'); + jasmine.restoreLibrary('../lib/LiveQuery/Client', 'Client'); + jasmine.restoreLibrary('../lib/LiveQuery/Subscription', 'Subscription'); + jasmine.restoreLibrary('../lib/LiveQuery/QueryTools', 'queryHash'); + jasmine.restoreLibrary('../lib/LiveQuery/QueryTools', 'matchesQuery'); + jasmine.restoreLibrary('../lib/LiveQuery/ParsePubSub', 'ParsePubSub'); + jasmine.restoreLibrary('../lib/LiveQuery/SessionTokenCache', 'SessionTokenCache'); }); // Helper functions to add mock client and subscription to a liveQueryServer function addMockClient(parseLiveQueryServer, clientId) { - const Client = require('../src/LiveQuery/Client').Client; + const Client = require('../lib/LiveQuery/Client').Client; const client = new Client(clientId, {}); parseLiveQueryServer.clients.set(clientId, client); return client; diff --git a/spec/ParseObject.spec.js b/spec/ParseObject.spec.js index aedf251118..954d21a6f4 100644 --- a/spec/ParseObject.spec.js +++ b/spec/ParseObject.spec.js @@ -1980,4 +1980,31 @@ describe('Parse.Object testing', () => { done(); }) }); + + it ('Update object field should store exactly same sent object', async (done) => { + let object = new TestObject(); + + // Set initial data + object.set("jsonData", { a: "b" }); + object = await object.save(); + equal(object.get('jsonData'), { a: "b" }); + + // Set empty JSON + object.set("jsonData", {}); + object = await object.save(); + equal(object.get('jsonData'), {}); + + // Set new JSON data + object.unset('jsonData') + object.set("jsonData", { c: "d" }); + object = await object.save(); + equal(object.get('jsonData'), { c: "d" }); + + // Fetch object from server + object = await object.fetch() + console.log(object.id, object.get('jsonData')) + equal(object.get('jsonData'), { c: "d" }); + + done(); + }); }); diff --git a/spec/ParsePolygon.spec.js b/spec/ParsePolygon.spec.js index 25d4edffa3..2527a09e55 100644 --- a/spec/ParsePolygon.spec.js +++ b/spec/ParsePolygon.spec.js @@ -1,5 +1,5 @@ const TestObject = Parse.Object.extend('TestObject'); -import MongoStorageAdapter from '../src/Adapters/Storage/Mongo/MongoStorageAdapter'; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase'; const rp = require('request-promise'); const defaultHeaders = { @@ -8,6 +8,9 @@ const defaultHeaders = { } describe('Parse.Polygon testing', () => { + + beforeAll(() => require('../lib/TestUtils').destroyAllDataPermanently()); + it('polygon save open path', (done) => { const coords = [[0,0],[0,1],[1,1],[1,0]]; const closed = [[0,0],[0,1],[1,1],[1,0],[0,0]]; @@ -128,144 +131,150 @@ describe('Parse.Polygon testing', () => { }, done.fail); }); - it('polygonContain query', (done) => { - const points1 = [[0,0],[0,1],[1,1],[1,0]]; - const points2 = [[0,0],[0,2],[2,2],[2,0]]; - const points3 = [[10,10],[10,15],[15,15],[15,10],[10,10]]; - const polygon1 = new Parse.Polygon(points1); - const polygon2 = new Parse.Polygon(points2); - const polygon3 = new Parse.Polygon(points3); - const obj1 = new TestObject({location: polygon1}); - const obj2 = new TestObject({location: polygon2}); - const obj3 = new TestObject({location: polygon3}); - Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { - const where = { - location: { - $geoIntersects: { - $point: { __type: 'GeoPoint', latitude: 0.5, longitude: 0.5 } + describe('with location', () => { + beforeAll(() => require('../lib/TestUtils').destroyAllDataPermanently()); + + it('polygonContain query', (done) => { + const points1 = [[0,0],[0,1],[1,1],[1,0]]; + const points2 = [[0,0],[0,2],[2,2],[2,0]]; + const points3 = [[10,10],[10,15],[15,15],[15,10],[10,10]]; + const polygon1 = new Parse.Polygon(points1); + const polygon2 = new Parse.Polygon(points2); + const polygon3 = new Parse.Polygon(points3); + const obj1 = new TestObject({location: polygon1}); + const obj2 = new TestObject({location: polygon2}); + const obj3 = new TestObject({location: polygon3}); + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + const where = { + location: { + $geoIntersects: { + $point: { __type: 'GeoPoint', latitude: 0.5, longitude: 0.5 } + } } - } - }; - return rp.post({ - url: Parse.serverURL + '/classes/TestObject', - json: { where, '_method': 'GET' }, - headers: { - 'X-Parse-Application-Id': Parse.applicationId, - 'X-Parse-Javascript-Key': Parse.javaScriptKey - } - }); - }).then((resp) => { - expect(resp.results.length).toBe(2); - done(); - }, done.fail); - }); + }; + return rp.post({ + url: Parse.serverURL + '/classes/TestObject', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((resp) => { + expect(resp.results.length).toBe(2); + done(); + }, done.fail); + }); - it('polygonContain query no reverse input (Regression test for #4608)', (done) => { - const points1 = [[.25,0],[.25,1.25],[.75,1.25],[.75,0]]; - const points2 = [[0,0],[0,2],[2,2],[2,0]]; - const points3 = [[10,10],[10,15],[15,15],[15,10],[10,10]]; - const polygon1 = new Parse.Polygon(points1); - const polygon2 = new Parse.Polygon(points2); - const polygon3 = new Parse.Polygon(points3); - const obj1 = new TestObject({location: polygon1}); - const obj2 = new TestObject({location: polygon2}); - const obj3 = new TestObject({location: polygon3}); - Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { - const where = { - location: { - $geoIntersects: { - $point: { __type: 'GeoPoint', latitude: 0.5, longitude:1.0 } + it('polygonContain query no reverse input (Regression test for #4608)', (done) => { + const points1 = [[.25,0],[.25,1.25],[.75,1.25],[.75,0]]; + const points2 = [[0,0],[0,2],[2,2],[2,0]]; + const points3 = [[10,10],[10,15],[15,15],[15,10],[10,10]]; + const polygon1 = new Parse.Polygon(points1); + const polygon2 = new Parse.Polygon(points2); + const polygon3 = new Parse.Polygon(points3); + const obj1 = new TestObject({location: polygon1}); + const obj2 = new TestObject({location: polygon2}); + const obj3 = new TestObject({location: polygon3}); + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + const where = { + location: { + $geoIntersects: { + $point: { __type: 'GeoPoint', latitude: 0.5, longitude:1.0 } + } } - } - }; - return rp.post({ - url: Parse.serverURL + '/classes/TestObject', - json: { where, '_method': 'GET' }, - headers: { - 'X-Parse-Application-Id': Parse.applicationId, - 'X-Parse-Javascript-Key': Parse.javaScriptKey - } - }); - }).then((resp) => { - expect(resp.results.length).toBe(2); - done(); - }, done.fail); - }); + }; + return rp.post({ + url: Parse.serverURL + '/classes/TestObject', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((resp) => { + expect(resp.results.length).toBe(2); + done(); + }, done.fail); + }); - it('polygonContain query real data (Regression test for #4608)', (done) => { - const detroit = [[42.631655189280224,-83.78406753121705],[42.633047793854814,-83.75333640366955],[42.61625254348911,-83.75149921669944],[42.61526926650296,-83.78161794858735],[42.631655189280224,-83.78406753121705]]; - const polygon = new Parse.Polygon(detroit); - const obj = new TestObject({location: polygon}); - obj.save().then(() => { - const where = { - location: { - $geoIntersects: { - $point: { __type: 'GeoPoint', latitude: 42.624599, longitude:-83.770162 } + it('polygonContain query real data (Regression test for #4608)', (done) => { + const detroit = [[42.631655189280224,-83.78406753121705],[42.633047793854814,-83.75333640366955],[42.61625254348911,-83.75149921669944],[42.61526926650296,-83.78161794858735],[42.631655189280224,-83.78406753121705]]; + const polygon = new Parse.Polygon(detroit); + const obj = new TestObject({location: polygon}); + obj.save().then(() => { + const where = { + location: { + $geoIntersects: { + $point: { __type: 'GeoPoint', latitude: 42.624599, longitude:-83.770162 } + } } - } - }; - return rp.post({ - url: Parse.serverURL + '/classes/TestObject', - json: { where, '_method': 'GET' }, - headers: { - 'X-Parse-Application-Id': Parse.applicationId, - 'X-Parse-Javascript-Key': Parse.javaScriptKey - } - }); - }).then((resp) => { - expect(resp.results.length).toBe(1); - done(); - }, done.fail); - }); + }; + return rp.post({ + url: Parse.serverURL + '/classes/TestObject', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((resp) => { + expect(resp.results.length).toBe(1); + done(); + }, done.fail); + }); - it('polygonContain invalid input', (done) => { - const points = [[0,0],[0,1],[1,1],[1,0]]; - const polygon = new Parse.Polygon(points); - const obj = new TestObject({location: polygon}); - obj.save().then(() => { - const where = { - location: { - $geoIntersects: { - $point: { __type: 'GeoPoint', latitude: 181, longitude: 181 } + it('polygonContain invalid input', (done) => { + const points = [[0,0],[0,1],[1,1],[1,0]]; + const polygon = new Parse.Polygon(points); + const obj = new TestObject({location: polygon}); + obj.save().then(() => { + const where = { + location: { + $geoIntersects: { + $point: { __type: 'GeoPoint', latitude: 181, longitude: 181 } + } } - } - }; - return rp.post({ - url: Parse.serverURL + '/classes/TestObject', - json: { where, '_method': 'GET' }, - headers: { - 'X-Parse-Application-Id': Parse.applicationId, - 'X-Parse-Javascript-Key': Parse.javaScriptKey - } - }); - }).then(done.fail, () => done()); - }); + }; + return rp.post({ + url: Parse.serverURL + '/classes/TestObject', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then(done.fail, () => done()); + }); - it('polygonContain invalid geoPoint', (done) => { - const points = [[0,0],[0,1],[1,1],[1,0]]; - const polygon = new Parse.Polygon(points); - const obj = new TestObject({location: polygon}); - obj.save().then(() => { - const where = { - location: { - $geoIntersects: { - $point: [] + it('polygonContain invalid geoPoint', (done) => { + const points = [[0,0],[0,1],[1,1],[1,0]]; + const polygon = new Parse.Polygon(points); + const obj = new TestObject({location: polygon}); + obj.save().then(() => { + const where = { + location: { + $geoIntersects: { + $point: [] + } } - } - }; - return rp.post({ - url: Parse.serverURL + '/classes/TestObject', - json: { where, '_method': 'GET' }, - headers: { - 'X-Parse-Application-Id': Parse.applicationId, - 'X-Parse-Javascript-Key': Parse.javaScriptKey - } - }); - }).then(done.fail, () => done()); + }; + return rp.post({ + url: Parse.serverURL + '/classes/TestObject', + json: { where, '_method': 'GET' }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then(done.fail, () => done()); + }); }); }); describe_only_db('mongo')('Parse.Polygon testing', () => { + + beforeEach(() => require('../lib/TestUtils').destroyAllDataPermanently()); it('support 2d and 2dsphere', (done) => { const coords = [[0,0],[0,1],[1,1],[1,0],[0,0]]; // testings against REST API, use raw formats @@ -314,7 +323,7 @@ describe_only_db('mongo')('Parse.Polygon testing', () => { }); it('polygon coordinates reverse input', (done) => { - const Config = require('../src/Config'); + const Config = require('../lib/Config'); const config = Config.get('test'); // When stored the first point should be the last point diff --git a/spec/ParsePubSub.spec.js b/spec/ParsePubSub.spec.js index 3c7014f7d2..fe8db147d6 100644 --- a/spec/ParsePubSub.spec.js +++ b/spec/ParsePubSub.spec.js @@ -1,4 +1,4 @@ -const ParsePubSub = require('../src/LiveQuery/ParsePubSub').ParsePubSub; +const ParsePubSub = require('../lib/LiveQuery/ParsePubSub').ParsePubSub; describe('ParsePubSub', function() { @@ -8,13 +8,13 @@ describe('ParsePubSub', function() { createPublisher: jasmine.createSpy('createPublisherRedis'), createSubscriber: jasmine.createSpy('createSubscriberRedis') }; - jasmine.mockLibrary('../src/Adapters/PubSub/RedisPubSub', 'RedisPubSub', mockRedisPubSub); + jasmine.mockLibrary('../lib/Adapters/PubSub/RedisPubSub', 'RedisPubSub', mockRedisPubSub); // Mock EventEmitterPubSub const mockEventEmitterPubSub = { createPublisher: jasmine.createSpy('createPublisherEventEmitter'), createSubscriber: jasmine.createSpy('createSubscriberEventEmitter') }; - jasmine.mockLibrary('../src/Adapters/PubSub/EventEmitterPubSub', 'EventEmitterPubSub', mockEventEmitterPubSub); + jasmine.mockLibrary('../lib/Adapters/PubSub/EventEmitterPubSub', 'EventEmitterPubSub', mockEventEmitterPubSub); done(); }); @@ -23,8 +23,8 @@ describe('ParsePubSub', function() { redisURL: 'redisURL' }); - const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; - const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; + const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; + const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; expect(RedisPubSub.createPublisher).toHaveBeenCalledWith({redisURL: 'redisURL'}); expect(EventEmitterPubSub.createPublisher).not.toHaveBeenCalled(); }); @@ -32,8 +32,8 @@ describe('ParsePubSub', function() { it('can create event emitter publisher', function() { ParsePubSub.createPublisher({}); - const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; - const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; + const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; + const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; expect(RedisPubSub.createPublisher).not.toHaveBeenCalled(); expect(EventEmitterPubSub.createPublisher).toHaveBeenCalled(); }); @@ -43,8 +43,8 @@ describe('ParsePubSub', function() { redisURL: 'redisURL' }); - const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; - const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; + const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; + const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; expect(RedisPubSub.createSubscriber).toHaveBeenCalledWith({redisURL: 'redisURL'}); expect(EventEmitterPubSub.createSubscriber).not.toHaveBeenCalled(); }); @@ -52,8 +52,8 @@ describe('ParsePubSub', function() { it('can create event emitter subscriber', function() { ParsePubSub.createSubscriber({}); - const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; - const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; + const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; + const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; expect(RedisPubSub.createSubscriber).not.toHaveBeenCalled(); expect(EventEmitterPubSub.createSubscriber).toHaveBeenCalled(); }); @@ -73,8 +73,8 @@ describe('ParsePubSub', function() { }); expect(adapter.createSubscriber).toHaveBeenCalled(); - const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; - const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; + const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; + const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; expect(RedisPubSub.createSubscriber).not.toHaveBeenCalled(); expect(EventEmitterPubSub.createSubscriber).not.toHaveBeenCalled(); expect(RedisPubSub.createPublisher).not.toHaveBeenCalled(); @@ -100,8 +100,8 @@ describe('ParsePubSub', function() { }); expect(adapter.createSubscriber).toHaveBeenCalled(); - const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; - const EventEmitterPubSub = require('../src/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; + const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; + const EventEmitterPubSub = require('../lib/Adapters/PubSub/EventEmitterPubSub').EventEmitterPubSub; expect(RedisPubSub.createSubscriber).not.toHaveBeenCalled(); expect(EventEmitterPubSub.createSubscriber).not.toHaveBeenCalled(); expect(RedisPubSub.createPublisher).not.toHaveBeenCalled(); @@ -109,7 +109,7 @@ describe('ParsePubSub', function() { }); afterEach(function(){ - jasmine.restoreLibrary('../src/Adapters/PubSub/RedisPubSub', 'RedisPubSub'); - jasmine.restoreLibrary('../src/Adapters/PubSub/EventEmitterPubSub', 'EventEmitterPubSub'); + jasmine.restoreLibrary('../lib/Adapters/PubSub/RedisPubSub', 'RedisPubSub'); + jasmine.restoreLibrary('../lib/Adapters/PubSub/EventEmitterPubSub', 'EventEmitterPubSub'); }); }); diff --git a/spec/ParseQuery.Aggregate.spec.js b/spec/ParseQuery.Aggregate.spec.js index dade21ca47..d3e1d19e7c 100644 --- a/spec/ParseQuery.Aggregate.spec.js +++ b/spec/ParseQuery.Aggregate.spec.js @@ -13,6 +13,10 @@ const masterKeyOptions = { json: true } +const PointerObject = Parse.Object.extend({ + className: "PointerObject" +}); + const loadTestData = () => { const data1 = {score: 10, name: 'foo', sender: {group: 'A'}, views: 900, size: ['S', 'M']}; const data2 = {score: 10, name: 'foo', sender: {group: 'A'}, views: 800, size: ['M', 'L']}; @@ -160,6 +164,124 @@ describe('Parse.Query Aggregate testing', () => { }); }); + it('group by date object transform', (done) => { + const obj1 = new TestObject(); + const obj2 = new TestObject(); + const obj3 = new TestObject(); + const pipeline = [{ + group: { + objectId: { day: { $dayOfMonth: "$updatedAt" }, month: { $month: "$createdAt" }, year: { $year: "$createdAt" } }, + count: { $sum: 1 } + } + }]; + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + const createdAt = new Date(obj1.createdAt); + expect(results[0].objectId.day).toEqual(createdAt.getUTCDate()); + expect(results[0].objectId.month).toEqual(createdAt.getMonth() + 1); + expect(results[0].objectId.year).toEqual(createdAt.getUTCFullYear()); + done(); + }); + }); + + it_exclude_dbs(['postgres'])('group and multiply transform', (done) => { + const obj1 = new TestObject({ name: 'item a', quantity: 2, price: 10 }); + const obj2 = new TestObject({ name: 'item b', quantity: 5, price: 5 }); + const pipeline = [{ + group: { + objectId: null, + total: { $sum: { $multiply: [ '$quantity', '$price' ] } } + } + }]; + Parse.Object.saveAll([obj1, obj2]).then(() => { + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toEqual(1); + expect(results[0].total).toEqual(45); + done(); + }); + }); + + it_exclude_dbs(['postgres'])('project and multiply transform', (done) => { + const obj1 = new TestObject({ name: 'item a', quantity: 2, price: 10 }); + const obj2 = new TestObject({ name: 'item b', quantity: 5, price: 5 }); + const pipeline = [ + { + match: { quantity: { $exists: true } } + }, + { + project: { + name: 1, + total: { $multiply: [ '$quantity', '$price' ] } + } + } + ]; + Parse.Object.saveAll([obj1, obj2]).then(() => { + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toEqual(2); + if (results[0].name === 'item a') { + expect(results[0].total).toEqual(20); + expect(results[1].total).toEqual(25); + } + else { + expect(results[0].total).toEqual(25); + expect(results[1].total).toEqual(20); + } + done(); + }); + }); + + it_exclude_dbs(['postgres'])('project without objectId transform', (done) => { + const obj1 = new TestObject({ name: 'item a', quantity: 2, price: 10 }); + const obj2 = new TestObject({ name: 'item b', quantity: 5, price: 5 }); + const pipeline = [ + { + match: { quantity: { $exists: true } } + }, + { + project: { + objectId: 0, + total: { $multiply: [ '$quantity', '$price' ] } + } + }, + { + sort: { total: 1 } + } + ]; + Parse.Object.saveAll([obj1, obj2]).then(() => { + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toEqual(2); + expect(results[0].total).toEqual(20); + expect(results[0].objectId).toEqual(undefined); + expect(results[1].total).toEqual(25); + expect(results[1].objectId).toEqual(undefined); + done(); + }); + }); + + it_exclude_dbs(['postgres'])('project updatedAt only transform', (done) => { + const pipeline = [{ + project: { objectId: 0, updatedAt: 1 } + }]; + const query = new Parse.Query(TestObject); + query.aggregate(pipeline).then((results) => { + expect(results.length).toEqual(4); + for (let i = 0; i < results.length; i++) { + const item = results[i]; + expect(item.hasOwnProperty('updatedAt')).toEqual(true); + expect(item.hasOwnProperty('objectId')).toEqual(false); + } + done(); + }); + }); + it_exclude_dbs(['postgres'])('cannot group by date field (excluding createdAt and updatedAt)', (done) => { const obj1 = new TestObject({ dateField: new Date(1990, 11, 1) }); const obj2 = new TestObject({ dateField: new Date(1990, 5, 1) }); @@ -173,7 +295,7 @@ describe('Parse.Query Aggregate testing', () => { Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { const query = new Parse.Query(TestObject); return query.aggregate(pipeline); - }).then(done.fail).catch((error) => { + }).then(done).catch((error) => { expect(error.code).toEqual(Parse.Error.INVALID_QUERY); done(); }); @@ -335,6 +457,27 @@ describe('Parse.Query Aggregate testing', () => { }).catch(done.fail); }); + it('match comparison date query', (done) => { + const today = new Date(); + const yesterday = new Date(); + const tomorrow = new Date(); + yesterday.setDate(today.getDate() - 1); + tomorrow.setDate(today.getDate() + 1); + const obj1 = new TestObject({ dateField: yesterday }); + const obj2 = new TestObject({ dateField: today }); + const obj3 = new TestObject({ dateField: tomorrow }); + const pipeline = [ + { match: { dateField: { $lt: tomorrow } } } + ]; + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toBe(2); + done(); + }); + }); + it('match comparison query', (done) => { const options = Object.assign({}, masterKeyOptions, { body: { @@ -448,8 +591,8 @@ describe('Parse.Query Aggregate testing', () => { }); it('match pointer query', (done) => { - const pointer1 = new TestObject(); - const pointer2 = new TestObject(); + const pointer1 = new PointerObject(); + const pointer2 = new PointerObject(); const obj1 = new TestObject({ pointer: pointer1 }); const obj2 = new TestObject({ pointer: pointer2 }); const obj3 = new TestObject({ pointer: pointer1 }); @@ -470,6 +613,96 @@ describe('Parse.Query Aggregate testing', () => { }); }); + it_exclude_dbs(['postgres'])('match exists query', (done) => { + const pipeline = [ + { match: { score: { $exists: true } } } + ]; + const query = new Parse.Query(TestObject); + query.aggregate(pipeline).then((results) => { + expect(results.length).toEqual(4); + done(); + }); + }); + + it('match date query - createdAt', (done) => { + const obj1 = new TestObject(); + const obj2 = new TestObject(); + + Parse.Object.saveAll([obj1, obj2]).then(() => { + const now = new Date(); + const today = new Date(now.getFullYear(), now.getMonth(), now.getDate()); + const pipeline = [ + { match: { 'createdAt': { $gte: today } } } + ]; + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + // Four objects were created initially, we added two more. + expect(results.length).toEqual(6); + done(); + }); + }); + + it('match date query - updatedAt', (done) => { + const obj1 = new TestObject(); + const obj2 = new TestObject(); + + Parse.Object.saveAll([obj1, obj2]).then(() => { + const now = new Date(); + const today = new Date(now.getFullYear(), now.getMonth(), now.getDate()); + const pipeline = [ + { match: { 'updatedAt': { $gte: today } } } + ]; + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + // Four objects were added initially, we added two more. + expect(results.length).toEqual(6); + done(); + }); + }); + + it('match date query - empty', (done) => { + const obj1 = new TestObject(); + const obj2 = new TestObject(); + + Parse.Object.saveAll([obj1, obj2]).then(() => { + const now = new Date(); + const future = new Date(now.getFullYear(), now.getMonth() + 1, now.getDate()); + const pipeline = [ + { match: { 'createdAt': future } } + ]; + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toEqual(0); + done(); + }); + }); + + it_exclude_dbs(['postgres'])('match pointer with operator query', (done) => { + const pointer = new PointerObject(); + + const obj1 = new TestObject({ pointer }); + const obj2 = new TestObject({ pointer }); + const obj3 = new TestObject(); + + Parse.Object.saveAll([pointer, obj1, obj2, obj3]).then(() => { + const pipeline = [ + { match: { pointer: { $exists: true } } } + ]; + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toEqual(2); + expect(results[0].pointer.objectId).toEqual(pointer.id); + expect(results[1].pointer.objectId).toEqual(pointer.id); + expect(results.some(result => result.objectId === obj1.id)).toEqual(true); + expect(results.some(result => result.objectId === obj2.id)).toEqual(true); + done(); + }); + }); + it('project query', (done) => { const options = Object.assign({}, masterKeyOptions, { body: { @@ -508,6 +741,26 @@ describe('Parse.Query Aggregate testing', () => { }).catch(done.fail); }); + it('project pointer query', (done) => { + const pointer = new PointerObject(); + const obj = new TestObject({ pointer, name: 'hello' }); + + obj.save().then(() => { + const pipeline = [ + { match: { objectId: obj.id } }, + { project: { pointer: 1, name: 1, createdAt: 1 } } + ]; + const query = new Parse.Query(TestObject); + return query.aggregate(pipeline); + }).then((results) => { + expect(results.length).toEqual(1); + expect(results[0].name).toEqual('hello'); + expect(results[0].createdAt).not.toBe(undefined); + expect(results[0].pointer.objectId).toEqual(pointer.id); + done(); + }); + }); + it('project with group query', (done) => { const options = Object.assign({}, masterKeyOptions, { body: { @@ -618,8 +871,8 @@ describe('Parse.Query Aggregate testing', () => { }); it('distinct pointer', (done) => { - const pointer1 = new TestObject(); - const pointer2 = new TestObject(); + const pointer1 = new PointerObject(); + const pointer2 = new PointerObject(); const obj1 = new TestObject({ pointer: pointer1 }); const obj2 = new TestObject({ pointer: pointer2 }); const obj3 = new TestObject({ pointer: pointer1 }); @@ -740,4 +993,47 @@ describe('Parse.Query Aggregate testing', () => { fail(err); }); }); + + it_exclude_dbs(['postgres'])('aggregate allow multiple of same stage', (done) => { + const pointer1 = new TestObject({ value: 1}); + const pointer2 = new TestObject({ value: 2}); + const pointer3 = new TestObject({ value: 3}); + + const obj1 = new TestObject({ pointer: pointer1, name: 'Hello' }); + const obj2 = new TestObject({ pointer: pointer2, name: 'Hello' }); + const obj3 = new TestObject({ pointer: pointer3, name: 'World' }); + + const options = Object.assign({}, masterKeyOptions, { + body: [{ + match: { name: "Hello" }, + }, { + // Transform className$objectId to objectId and store in new field tempPointer + project: { + tempPointer: { $substr: [ "$_p_pointer", 11, -1 ] }, // Remove TestObject$ + }, + }, { + // Left Join, replace objectId stored in tempPointer with an actual object + lookup: { + from: "test_TestObject", + localField: "tempPointer", + foreignField: "_id", + as: "tempPointer" + }, + }, { + // lookup returns an array, Deconstructs an array field to objects + unwind: { + path: "$tempPointer", + }, + }, { + match : { "tempPointer.value" : 2 }, + }] + }); + Parse.Object.saveAll([pointer1, pointer2, pointer3, obj1, obj2, obj3]).then(() => { + return rp.get(Parse.serverURL + '/aggregate/TestObject', options); + }).then((resp) => { + expect(resp.results.length).toEqual(1); + expect(resp.results[0].tempPointer.value).toEqual(2); + done(); + }); + }); }); diff --git a/spec/ParseQuery.FullTextSearch.spec.js b/spec/ParseQuery.FullTextSearch.spec.js index 9116410742..eac29c9268 100644 --- a/spec/ParseQuery.FullTextSearch.spec.js +++ b/spec/ParseQuery.FullTextSearch.spec.js @@ -1,8 +1,8 @@ 'use strict'; -import MongoStorageAdapter from '../src/Adapters/Storage/Mongo/MongoStorageAdapter'; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase'; -import PostgresStorageAdapter from '../src/Adapters/Storage/Postgres/PostgresStorageAdapter'; +const PostgresStorageAdapter = require('../lib/Adapters/Storage/Postgres/PostgresStorageAdapter').default; const postgresURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database'; const Parse = require('parse/node'); const rp = require('request-promise'); @@ -280,7 +280,7 @@ describe('Parse.Query Full Text Search testing', () => { }); }); -describe_only_db('mongo')('Parse.Query Full Text Search testing', () => { +describe_only_db('mongo')('[mongodb] Parse.Query Full Text Search testing', () => { it('fullTextSearch: does not create text index if compound index exist', (done) => { fullTextHelper().then(() => { return databaseAdapter.dropAllIndexes('TestObject'); @@ -451,7 +451,7 @@ describe_only_db('mongo')('Parse.Query Full Text Search testing', () => { }); }); -describe_only_db('postgres')('Parse.Query Full Text Search testing', () => { +describe_only_db('postgres')('[postgres] Parse.Query Full Text Search testing', () => { it('fullTextSearch: $diacriticSensitive - false', (done) => { fullTextHelper().then(() => { const where = { diff --git a/spec/ParseQuery.spec.js b/spec/ParseQuery.spec.js index 662b58fa5c..694b870f71 100644 --- a/spec/ParseQuery.spec.js +++ b/spec/ParseQuery.spec.js @@ -5,6 +5,18 @@ 'use strict'; const Parse = require('parse/node'); +const rp = require('request-promise'); + +const masterKeyHeaders = { + 'X-Parse-Application-Id': 'test', + 'X-Parse-Rest-API-Key': 'test', + 'X-Parse-Master-Key': 'test' +} + +const masterKeyOptions = { + headers: masterKeyHeaders, + json: true +} describe('Parse.Query testing', () => { it("basic query", function(done) { @@ -497,6 +509,354 @@ describe('Parse.Query testing', () => { }); }); + it('containsAllStartingWith should match all strings that starts with string', (done) => { + + const object = new Parse.Object('Object'); + object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']); + const object2 = new Parse.Object('Object'); + object2.set('strings', ['the', 'brown', 'fox', 'jumps']); + const object3 = new Parse.Object('Object'); + object3.set('strings', ['over', 'the', 'lazy', 'dog']); + + const objectList = [object, object2, object3]; + + Parse.Object.saveAll(objectList).then((results) => { + equal(objectList.length, results.length); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ + {$regex: '\^\\Qthe\\E'}, + {$regex: '\^\\Qfox\\E'}, + {$regex: '\^\\Qlazy\\E'} + ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }) + .then(function (results) { + equal(results.results.length, 1); + arrayContains(results.results, object); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ + {$regex: '\^\\Qthe\\E'}, + {$regex: '\^\\Qlazy\\E'} + ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function (results) { + equal(results.results.length, 2); + arrayContains(results.results, object); + arrayContains(results.results, object3); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ + {$regex: '\^\\Qhe\\E'}, + {$regex: '\^\\Qlazy\\E'} + ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function (results) { + equal(results.results.length, 0); + + done(); + }); + }); + }); + + it('containsAllStartingWith values must be all of type starting with regex', (done) => { + + const object = new Parse.Object('Object'); + object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']); + + object.save().then(() => { + equal(object.isNew(), false); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ + {$regex: '\^\\Qthe\\E'}, + {$regex: '\^\\Qlazy\\E'}, + {$regex: '\^\\Qfox\\E'}, + {$unknown: /unknown/} + ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function () { + }, function () { + done(); + }); + }); + + it('containsAllStartingWith empty array values should return empty results', (done) => { + + const object = new Parse.Object('Object'); + object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']); + + object.save().then(() => { + equal(object.isNew(), false); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function (results) { + equal(results.results.length, 0); + done(); + }, function () { + }); + }); + + it('containsAllStartingWith single empty value returns empty results', (done) => { + + const object = new Parse.Object('Object'); + object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']); + + object.save().then(() => { + equal(object.isNew(), false); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ {} ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function (results) { + equal(results.results.length, 0); + done(); + }, function () { + }); + }); + + it('containsAllStartingWith single regex value should return corresponding matching results', (done) => { + + const object = new Parse.Object('Object'); + object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']); + const object2 = new Parse.Object('Object'); + object2.set('strings', ['the', 'brown', 'fox', 'jumps']); + const object3 = new Parse.Object('Object'); + object3.set('strings', ['over', 'the', 'lazy', 'dog']); + + const objectList = [object, object2, object3]; + + Parse.Object.saveAll(objectList).then((results) => { + equal(objectList.length, results.length); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ {$regex: '\^\\Qlazy\\E'} ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function (results) { + equal(results.results.length, 2); + done(); + }, function () { + }); + }); + + it('containsAllStartingWith single invalid regex returns empty results', (done) => { + + const object = new Parse.Object('Object'); + object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']); + + object.save().then(() => { + equal(object.isNew(), false); + + return require('request-promise').get({ + url: Parse.serverURL + "/classes/Object", + json: { + where: { + strings: { + $all: [ {$unknown: '\^\\Qlazy\\E'} ] + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }) + .then(function (results) { + equal(results.results.length, 0); + done(); + }, function () { + }); + }); + + it('containedBy pointer array', (done) => { + const objects = Array.from(Array(10).keys()).map((idx) => { + const obj = new Parse.Object('Object'); + obj.set('key', idx); + return obj; + }); + + const parent = new Parse.Object('Parent'); + const parent2 = new Parse.Object('Parent'); + const parent3 = new Parse.Object('Parent'); + + Parse.Object.saveAll(objects).then(() => { + // [0, 1, 2] + parent.set('objects', objects.slice(0, 3)); + + const shift = objects.shift(); + // [2, 0] + parent2.set('objects', [objects[1], shift]); + + // [1, 2, 3, 4] + parent3.set('objects', objects.slice(1, 4)); + + return Parse.Object.saveAll([parent, parent2, parent3]); + }).then(() => { + // [1, 2, 3, 4, 5, 6, 7, 8, 9] + const pointers = objects.map(object => object.toPointer()); + + // Return all Parent where all parent.objects are contained in objects + return rp.get({ + url: Parse.serverURL + "/classes/Parent", + json: { + where: { + objects: { + $containedBy: pointers + } + } + }, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-Javascript-Key': Parse.javaScriptKey + } + }); + }).then((results) => { + expect(results.results[0].objectId).not.toBeUndefined(); + expect(results.results[0].objectId).toBe(parent3.id); + expect(results.results.length).toBe(1); + done(); + }); + }); + + + it('containedBy number array', (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { numbers: { $containedBy: [1, 2, 3, 4, 5, 6, 7, 8, 9] } }, + } + }); + const obj1 = new TestObject({ numbers: [0, 1, 2] }); + const obj2 = new TestObject({ numbers: [2, 0] }); + const obj3 = new TestObject({ numbers: [1, 2, 3, 4] }); + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + return rp.get(Parse.serverURL + "/classes/TestObject", options); + }).then((results) => { + expect(results.results[0].objectId).not.toBeUndefined(); + expect(results.results[0].objectId).toBe(obj3.id); + expect(results.results.length).toBe(1); + done(); + }); + }); + + it('containedBy empty array', (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { numbers: { $containedBy: [] } }, + } + }); + const obj1 = new TestObject({ numbers: [0, 1, 2] }); + const obj2 = new TestObject({ numbers: [2, 0] }); + const obj3 = new TestObject({ numbers: [1, 2, 3, 4] }); + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + return rp.get(Parse.serverURL + "/classes/TestObject", options); + }).then((results) => { + expect(results.results.length).toBe(0); + done(); + }); + }); + + it('containedBy invalid query', (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { objects: { $containedBy: 1234 } }, + } + }); + const obj = new TestObject(); + obj.save().then(() => { + return rp.get(Parse.serverURL + "/classes/TestObject", options); + }).then(done.fail).catch((error) => { + equal(error.error.code, Parse.Error.INVALID_JSON); + equal(error.error.error, 'bad $containedBy: should be an array'); + done(); + }); + }); + const BoxedNumber = Parse.Object.extend({ className: "BoxedNumber" }); @@ -570,6 +930,38 @@ describe('Parse.Query testing', () => { }); }); + it("lessThan zero queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.lessThan('number', 0); + return query.find(); + }).then((results) => { + equal(results.length, 3); + done(); + }); + }); + + it("lessThanOrEqualTo zero queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.lessThanOrEqualTo('number', 0); + return query.find(); + }).then((results) => { + equal(results.length, 4); + done(); + }); + }); + it("greaterThan queries", function(done) { const makeBoxedNumber = function(i) { return new BoxedNumber({ number: i }); @@ -606,6 +998,38 @@ describe('Parse.Query testing', () => { }); }); + it("greaterThan zero queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.greaterThan('number', 0); + return query.find(); + }).then((results) => { + equal(results.length, 1); + done(); + }); + }); + + it("greaterThanOrEqualTo zero queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.greaterThanOrEqualTo('number', 0); + return query.find(); + }).then((results) => { + equal(results.length, 2); + done(); + }); + }); + it("lessThanOrEqualTo greaterThanOrEqualTo queries", function(done) { const makeBoxedNumber = function(i) { return new BoxedNumber({ number: i }); @@ -662,6 +1086,101 @@ describe('Parse.Query testing', () => { }); }); + it("notEqualTo zero queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.notEqualTo('number', 0); + return query.find(); + }).then((results) => { + equal(results.length, 4); + done(); + }); + }); + + it("equalTo zero queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.equalTo('number', 0); + return query.find(); + }).then((results) => { + equal(results.length, 1); + done(); + }); + }); + + it("number equalTo boolean queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.equalTo('number', false); + return query.find(); + }).then((results) => { + equal(results.length, 0); + done(); + }); + }); + + it("equalTo false queries", (done) => { + const obj1 = new TestObject({ field: false }); + const obj2 = new TestObject({ field: true }); + Parse.Object.saveAll([obj1, obj2]).then(() => { + const query = new Parse.Query(TestObject); + query.equalTo('field', false); + return query.find(); + }).then((results) => { + equal(results.length, 1); + done(); + }); + }); + + it("where $eq false queries (rest)", (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { field: { $eq: false } }, + } + }); + const obj1 = new TestObject({ field: false }); + const obj2 = new TestObject({ field: true }); + Parse.Object.saveAll([obj1, obj2]).then(() => { + rp.get(Parse.serverURL + '/classes/TestObject', options) + .then((resp) => { + equal(resp.results.length, 1); + done(); + }); + }) + }); + + it("where $eq null queries (rest)", (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { field: { $eq: null } }, + } + }); + const obj1 = new TestObject({ field: false }); + const obj2 = new TestObject({ field: null }); + Parse.Object.saveAll([obj1, obj2]).then(() => { + rp.get(Parse.serverURL + '/classes/TestObject', options) + .then((resp) => { + equal(resp.results.length, 1); + done(); + }); + }) + }); + it("containedIn queries", function(done) { const makeBoxedNumber = function(i) { return new BoxedNumber({ number: i }); @@ -680,6 +1199,40 @@ describe('Parse.Query testing', () => { }); }); + it("containedIn false queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.containedIn('number', false); + return query.find(); + }).then(done.fail).catch((error) => { + equal(error.code, Parse.Error.INVALID_JSON); + equal(error.message, 'bad $in value'); + done(); + }); + }); + + it("notContainedIn false queries", (done) => { + const makeBoxedNumber = (i) => { + return new BoxedNumber({ number: i }); + }; + const numbers = [-3, -2, -1, 0, 1]; + const boxedNumbers = numbers.map(makeBoxedNumber); + Parse.Object.saveAll(boxedNumbers).then(() => { + const query = new Parse.Query(BoxedNumber); + query.notContainedIn('number', false); + return query.find(); + }).then(done.fail).catch((error) => { + equal(error.code, Parse.Error.INVALID_JSON); + equal(error.message, 'bad $nin value'); + done(); + }); + }); + it("notContainedIn queries", function(done) { const makeBoxedNumber = function(i) { return new BoxedNumber({ number: i }); @@ -985,6 +1538,90 @@ describe('Parse.Query testing', () => { }); }); + it('can order on an object string field', function (done) { + const testSet = [ + { sortField: { value: "Z" } }, + { sortField: { value: "A" } }, + { sortField: { value: "M" } }, + ]; + + const objects = testSet.map(e => new Parse.Object('Test', e)); + Parse.Object.saveAll(objects) + .then(() => new Parse.Query('Test').addDescending('sortField.value').first()) + .then((result) => { + expect(result.get('sortField').value).toBe("Z"); + return new Parse.Query('Test').addAscending('sortField.value').first() + }) + .then((result) => { + expect(result.get('sortField').value).toBe("A"); + done(); + }) + .catch(done.fail); + }); + + it('can order on an object string field (level 2)', function (done) { + const testSet = [ + { sortField: { value: { field: "Z" } } }, + { sortField: { value: { field: "A" } } }, + { sortField: { value: { field: "M" } } }, + ]; + + const objects = testSet.map(e => new Parse.Object('Test', e)); + Parse.Object.saveAll(objects) + .then(() => new Parse.Query('Test').addDescending('sortField.value.field').first()) + .then((result) => { + expect(result.get('sortField').value.field).toBe("Z"); + return new Parse.Query('Test').addAscending('sortField.value.field').first() + }) + .then((result) => { + expect(result.get('sortField').value.field).toBe("A"); + done(); + }) + .catch(done.fail); + }); + + it('can order on an object number field', function (done) { + const testSet = [ + { sortField: { value: 10 } }, + { sortField: { value: 1 } }, + { sortField: { value: 5 } }, + ]; + + const objects = testSet.map(e => new Parse.Object('Test', e)); + Parse.Object.saveAll(objects) + .then(() => new Parse.Query('Test').addDescending('sortField.value').first()) + .then((result) => { + expect(result.get('sortField').value).toBe(10); + return new Parse.Query('Test').addAscending('sortField.value').first() + }) + .then((result) => { + expect(result.get('sortField').value).toBe(1); + done(); + }) + .catch(done.fail); + }); + + it('can order on an object number field (level 2)', function (done) { + const testSet = [ + { sortField: { value: { field: 10 } } }, + { sortField: { value: { field: 1 } } }, + { sortField: { value: { field: 5 } } }, + ]; + + const objects = testSet.map(e => new Parse.Object('Test', e)); + Parse.Object.saveAll(objects) + .then(() => new Parse.Query('Test').addDescending('sortField.value.field').first()) + .then((result) => { + expect(result.get('sortField').value.field).toBe(10); + return new Parse.Query('Test').addAscending('sortField.value.field').first() + }) + .then((result) => { + expect(result.get('sortField').value.field).toBe(1); + done(); + }) + .catch(done.fail); + }); + it("order by ascending number then descending string", function(done) { const strings = ["a", "b", "c", "d"]; const makeBoxedNumber = function(num, i) { @@ -1387,7 +2024,7 @@ describe('Parse.Query testing', () => { query.find(expectError(Parse.Error.INVALID_QUERY, done)); }); - it("Use a regex that requires all modifiers", function(done) { + xit("Use a regex that requires all modifiers", function(done) { const thing = new TestObject(); thing.set("myString", "PArSe\nCom"); Parse.Object.saveAll([thing], function() { @@ -2014,6 +2651,63 @@ describe('Parse.Query testing', () => { }); }); + it('$nor valid query', (done) => { + const objects = Array.from(Array(10).keys()).map((rating) => { + return new TestObject({ 'rating': rating }); + }); + + const highValue = 5; + const lowValue = 3; + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { + $nor: [ + { rating : { $gt : highValue } }, + { rating : { $lte : lowValue } }, + ] + }, + } + }); + + Parse.Object.saveAll(objects).then(() => { + return rp.get(Parse.serverURL + "/classes/TestObject", options); + }).then((results) => { + expect(results.results.length).toBe(highValue - lowValue); + expect(results.results.every(res => res.rating > lowValue && res.rating <= highValue)).toBe(true); + done(); + }); + }); + + it('$nor invalid query - empty array', (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { $nor: [] }, + } + }); + const obj = new TestObject(); + obj.save().then(() => { + return rp.get(Parse.serverURL + "/classes/TestObject", options); + }).then(done.fail).catch((error) => { + equal(error.error.code, Parse.Error.INVALID_QUERY); + done(); + }); + }); + + it('$nor invalid query - wrong type', (done) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { $nor: 1337 }, + } + }); + const obj = new TestObject(); + obj.save().then(() => { + return rp.get(Parse.serverURL + "/classes/TestObject", options); + }).then(done.fail).catch((error) => { + equal(error.error.code, Parse.Error.INVALID_QUERY); + done(); + }); + }); + it("dontSelect query", function(done) { const RestaurantObject = Parse.Object.extend("Restaurant"); const PersonObject = Parse.Object.extend("Person"); @@ -2990,6 +3684,75 @@ describe('Parse.Query testing', () => { }); }); + it('includeAll', (done) => { + const child1 = new TestObject({ foo: 'bar', name: 'ac' }); + const child2 = new TestObject({ foo: 'baz', name: 'flo' }); + const child3 = new TestObject({ foo: 'bad', name: 'mo' }); + const parent = new Container({ child1, child2, child3 }); + Parse.Object.saveAll([parent, child1, child2, child3]).then(() => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { objectId: parent.id }, + includeAll: true, + } + }); + return rp.get(Parse.serverURL + "/classes/Container", options); + }).then((resp) => { + const result = resp.results[0]; + equal(result.child1.foo, 'bar'); + equal(result.child2.foo, 'baz'); + equal(result.child3.foo, 'bad'); + equal(result.child1.name, 'ac'); + equal(result.child2.name, 'flo'); + equal(result.child3.name, 'mo'); + done(); + }); + }); + + it('select nested keys 2 level includeAll', (done) => { + const Foobar = new Parse.Object('Foobar'); + const BarBaz = new Parse.Object('Barbaz'); + const Bazoo = new Parse.Object('Bazoo'); + const Tang = new Parse.Object('Tang'); + + Bazoo.set('some', 'thing'); + Bazoo.set('otherSome', 'value'); + Bazoo.save().then(() => { + BarBaz.set('key', 'value'); + BarBaz.set('otherKey', 'value'); + BarBaz.set('bazoo', Bazoo); + return BarBaz.save(); + }).then(() => { + Tang.set('clan', 'wu'); + return Tang.save(); + }).then(() => { + Foobar.set('foo', 'bar'); + Foobar.set('fizz', 'buzz'); + Foobar.set('barBaz', BarBaz); + Foobar.set('group', Tang); + return Foobar.save(); + }).then((savedFoobar) => { + const options = Object.assign({}, masterKeyOptions, { + body: { + where: { objectId: savedFoobar.id }, + includeAll: true, + keys: 'fizz,barBaz.key,barBaz.bazoo.some', + } + }); + return rp.get(Parse.serverURL + "/classes/Foobar", options); + }).then((resp) => { + const result = resp.results[0]; + equal(result.group.clan, 'wu'); + equal(result.foo, undefined); + equal(result.fizz, 'buzz'); + equal(result.barBaz.key, 'value'); + equal(result.barBaz.otherKey, undefined); + equal(result.barBaz.bazoo.some, 'thing'); + equal(result.barBaz.bazoo.otherSome, undefined); + done(); + }) + }); + it('select nested keys 2 level without include (issue #3185)', function(done) { const Foobar = new Parse.Object('Foobar'); const BarBaz = new Parse.Object('Barbaz'); @@ -3291,4 +4054,106 @@ describe('Parse.Query testing', () => { }) }); + it('withJSON supports geoWithin.centerSphere', (done) => { + const inbound = new Parse.GeoPoint(1.5, 1.5); + const onbound = new Parse.GeoPoint(10, 10); + const outbound = new Parse.GeoPoint(20, 20); + const obj1 = new Parse.Object('TestObject', {location: inbound}); + const obj2 = new Parse.Object('TestObject', {location: onbound}); + const obj3 = new Parse.Object('TestObject', {location: outbound}); + const center = new Parse.GeoPoint(0, 0); + const distanceInKilometers = 1569 + 1; // 1569km is the approximate distance between {0, 0} and {10, 10}. + Parse.Object.saveAll([obj1, obj2, obj3]).then(() => { + const q = new Parse.Query(TestObject); + const jsonQ = q.toJSON(); + jsonQ.where.location = { + '$geoWithin': { + '$centerSphere': [ + center, + distanceInKilometers / 6371.0 + ] + } + }; + q.withJSON(jsonQ); + return q.find(); + }).then(results => { + equal(results.length, 2); + const q = new Parse.Query(TestObject); + const jsonQ = q.toJSON(); + jsonQ.where.location = { + '$geoWithin': { + '$centerSphere': [ + [0, 0], + distanceInKilometers / 6371.0 + ] + } + }; + q.withJSON(jsonQ); + return q.find(); + }).then(results => { + equal(results.length, 2); + done(); + }).catch(error => { + fail(error); + done(); + }); + }); + + it('withJSON with geoWithin.centerSphere fails without parameters', (done) => { + const q = new Parse.Query(TestObject); + const jsonQ = q.toJSON(); + jsonQ.where.location = { + '$geoWithin': { + '$centerSphere': [ + ] + } + }; + q.withJSON(jsonQ); + q.find(expectError(Parse.Error.INVALID_JSON, done)); + }); + + it('withJSON with geoWithin.centerSphere fails with invalid distance', (done) => { + const q = new Parse.Query(TestObject); + const jsonQ = q.toJSON(); + jsonQ.where.location = { + '$geoWithin': { + '$centerSphere': [ + [0, 0], + 'invalid_distance' + ] + } + }; + q.withJSON(jsonQ); + q.find(expectError(Parse.Error.INVALID_JSON, done)); + }); + + it('withJSON with geoWithin.centerSphere fails with invalid coordinate', (done) => { + const q = new Parse.Query(TestObject); + const jsonQ = q.toJSON(); + jsonQ.where.location = { + '$geoWithin': { + '$centerSphere': [ + [-190,-190], + 1 + ] + } + }; + q.withJSON(jsonQ); + q.find(expectError(undefined, done)); + }); + + it('withJSON with geoWithin.centerSphere fails with invalid geo point', (done) => { + const q = new Parse.Query(TestObject); + const jsonQ = q.toJSON(); + jsonQ.where.location = { + '$geoWithin': { + '$centerSphere': [ + {'longitude': 0, 'dummytude': 0}, + 1 + ] + } + }; + q.withJSON(jsonQ); + q.find(expectError(undefined, done)); + }); }); diff --git a/spec/ParseRelation.spec.js b/spec/ParseRelation.spec.js index ad5ba361df..c780781995 100644 --- a/spec/ParseRelation.spec.js +++ b/spec/ParseRelation.spec.js @@ -801,4 +801,37 @@ describe('Parse.Relation testing', () => { done(); }); }); + + it('ensures beforeFind on relation doesnt side effect', (done) => { + const parent = new Parse.Object('Parent'); + const child = new Parse.Object('Child'); + child.save().then(() => { + parent.relation('children').add(child); + return parent.save(); + }).then(() => { + // We need to use a new reference otherwise the JS SDK remembers the className for a relation + // After saves or finds + const otherParent = new Parse.Object('Parent'); + otherParent.id = parent.id; + return otherParent.relation('children').query().find(); + }).then((children) => { + // Without an after find all is good, all results have been redirected with proper className + children.forEach((child) => expect(child.className).toBe('Child')); + // Setup the afterFind + Parse.Cloud.afterFind('Child', (req) => { + return Promise.resolve(req.objects.map((child) => { + child.set('afterFound', true); + return child; + })); + }); + const otherParent = new Parse.Object('Parent'); + otherParent.id = parent.id; + return otherParent.relation('children').query().find(); + }).then((children) => { + children.forEach((child) => { + expect(child.className).toBe('Child'); + expect(child.get('afterFound')).toBe(true); + }); + }).then(done).catch(done.fail); + }); }); diff --git a/spec/ParseRole.spec.js b/spec/ParseRole.spec.js index b9d315060a..21b430dbfe 100644 --- a/spec/ParseRole.spec.js +++ b/spec/ParseRole.spec.js @@ -2,9 +2,9 @@ // Roles are not accessible without the master key, so they are not intended // for use by clients. We can manually test them using the master key. -const RestQuery = require("../src/RestQuery"); -const Auth = require("../src/Auth").Auth; -const Config = require("../src/Config"); +const RestQuery = require("../lib/RestQuery"); +const Auth = require("../lib/Auth").Auth; +const Config = require("../lib/Config"); describe('Parse Role testing', () => { it('Do a bunch of basic role testing', done => { diff --git a/spec/ParseServer.spec.js b/spec/ParseServer.spec.js index c5f945a238..121ba4ae94 100644 --- a/spec/ParseServer.spec.js +++ b/spec/ParseServer.spec.js @@ -1,19 +1,26 @@ 'use strict'; /* Tests for ParseServer.js */ const express = require('express'); -import MongoStorageAdapter from '../src/Adapters/Storage/Mongo/MongoStorageAdapter'; -import PostgresStorageAdapter from '../src/Adapters/Storage/Postgres/PostgresStorageAdapter'; -import ParseServer from '../src/ParseServer'; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; +const PostgresStorageAdapter = require('../lib/Adapters/Storage/Postgres/PostgresStorageAdapter').default; +const ParseServer = require('../lib/ParseServer').default; describe('Server Url Checks', () => { - const app = express(); - app.get('/health', function(req, res){ - res.json({ - status: 'ok' + let server; + beforeAll((done) => { + const app = express(); + app.get('/health', function(req, res){ + res.json({ + status: 'ok' + }); }); + server = app.listen(13376, undefined, done); + }); + + afterAll((done) => { + server.close(done); }); - app.listen(13376); it('validate good server url', (done) => { Parse.serverURL = 'http://localhost:13376'; diff --git a/spec/ParseServerRESTController.spec.js b/spec/ParseServerRESTController.spec.js index a33244c0ba..4759d1a551 100644 --- a/spec/ParseServerRESTController.spec.js +++ b/spec/ParseServerRESTController.spec.js @@ -1,5 +1,5 @@ -const ParseServerRESTController = require('../src/ParseServerRESTController').ParseServerRESTController; -const ParseServer = require('../src/ParseServer').default; +const ParseServerRESTController = require('../lib/ParseServerRESTController').ParseServerRESTController; +const ParseServer = require('../lib/ParseServer').default; const Parse = require('parse/node').Parse; let RESTController; diff --git a/spec/ParseUser.spec.js b/spec/ParseUser.spec.js index f714cf90a0..3e34700810 100644 --- a/spec/ParseUser.spec.js +++ b/spec/ParseUser.spec.js @@ -7,9 +7,10 @@ "use strict"; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; const request = require('request'); -const passwordCrypto = require('../src/password'); -const Config = require('../src/Config'); +const passwordCrypto = require('../lib/password'); +const Config = require('../lib/Config'); const rp = require('request-promise'); function verifyACL(user) { @@ -100,7 +101,7 @@ describe('Parse.User testing', () => { }); }); - it('user login with non-string username with REST API', (done) => { + it('user login with non-string username with REST API (again)', (done) => { Parse.User.signUp('asdf', 'zxcv', null, { success: () => { return rp.post({ @@ -213,6 +214,106 @@ describe('Parse.User testing', () => { }) }); + it('should let masterKey lockout user', (done) => { + const user = new Parse.User(); + const ACL = new Parse.ACL(); + ACL.setPublicReadAccess(false); + ACL.setPublicWriteAccess(false); + user.setUsername('asdf'); + user.setPassword('zxcv'); + user.setACL(ACL); + user.signUp().then(() => { + return Parse.User.logIn("asdf", "zxcv"); + }).then((user) => { + equal(user.get("username"), "asdf"); + // Lock the user down + const ACL = new Parse.ACL(); + user.setACL(ACL); + return user.save(null, { useMasterKey: true }); + }).then(() => { + expect(user.getACL().getPublicReadAccess()).toBe(false); + return Parse.User.logIn("asdf", "zxcv"); + }).then(done.fail).catch((err) => { + expect(err.message).toBe('Invalid username/password.'); + expect(err.code).toBe(Parse.Error.OBJECT_NOT_FOUND); + done(); + }); + }); + + it_only_db('mongo')('should let legacy users without ACL login', async() => { + const databaseURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase'; + const adapter = new MongoStorageAdapter({ collectionPrefix: 'test_', uri: databaseURI }); + await adapter.connect(); + await adapter.database.dropDatabase(); + delete adapter.connectionPromise; + + const user = new Parse.User(); + await user.signUp({ + username: 'newUser', + password: 'password', + }); + + const collection = await adapter._adaptiveCollection('_User'); + await collection.insertOne({ + // the hashed password is 'password' hashed + "_hashed_password": "$2b$10$mJ2ca2UbCM9hlojYHZxkQe8pyEXe5YMg0nMdvP4AJBeqlTEZJ6/Uu", + "_session_token": "xxx", + "email": "xxx@a.b", + "username": "oldUser", + "emailVerified": true, + "_email_verify_token": "yyy", + }); + + // get the 2 users + const users = await collection.find(); + expect(users.length).toBe(2); + + const aUser = await Parse.User.logIn('oldUser', 'password'); + expect(aUser).not.toBeUndefined(); + + const newUser = await Parse.User.logIn('newUser', 'password'); + expect(newUser).not.toBeUndefined(); + }); + + it('should be let masterKey lock user out with authData', (done) => { + let objectId; + let sessionToken; + + rp.post({ + url: 'http://localhost:8378/1/classes/_User', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest', + }, + json: { key: "value", authData: {anonymous: {id: '00000000-0000-0000-0000-000000000001'}}} + }).then((body) => { + objectId = body.objectId; + sessionToken = body.sessionToken; + expect(sessionToken).toBeDefined(); + expect(objectId).toBeDefined(); + const user = new Parse.User(); + user.id = objectId; + const ACL = new Parse.ACL(); + user.setACL(ACL); + return user.save(null, { useMasterKey: true }); + }).then(() => { + // update the user + const options = { + url: `http://localhost:8378/1/classes/_User/`, + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest', + }, + json: { key: "otherValue", authData: {anonymous: {id: '00000000-0000-0000-0000-000000000001'}}} + } + return rp.post(options); + }).then((res) => { + // Because the user is locked out, this should behave as creating a new user + expect(res.objectId).not.toEqual(objectId); + }).then(done) + .catch(done.fail); + }); + it("user login with files", (done) => { const file = new Parse.File("yolo.txt", [1,2,3], "text/plain"); file.save().then((file) => { @@ -424,6 +525,71 @@ describe('Parse.User testing', () => { }); }); + it('never locks himself up', async () => { + const user = new Parse.User(); + await user.signUp({ + username: 'username', + password: 'password' + }); + user.setACL(new Parse.ACL()); + await user.save(); + await user.fetch(); + expect(user.getACL().getReadAccess(user)).toBe(true); + expect(user.getACL().getWriteAccess(user)).toBe(true); + const publicReadACL = new Parse.ACL(); + publicReadACL.setPublicReadAccess(true); + + // Create an administrator role with a single admin user + const role = new Parse.Role('admin', publicReadACL); + const admin = new Parse.User(); + await admin.signUp({ + username: 'admin', + password: 'admin', + }); + role.getUsers().add(admin); + await role.save(null, { useMasterKey: true }); + + // Grant the admins write rights on the user + const acl = user.getACL(); + acl.setRoleWriteAccess(role, true); + acl.setRoleReadAccess(role, true); + + // Update with the masterKey just to be sure + await user.save({ ACL: acl }, { useMasterKey: true }); + + // Try to update from admin... should all work fine + await user.save({ key: 'fromAdmin'}, { sessionToken: admin.getSessionToken() }); + await user.fetch(); + expect(user.toJSON().key).toEqual('fromAdmin'); + + // Try to save when logged out (public) + let failed = false; + try { + // Ensure no session token is sent + await Parse.User.logOut(); + await user.save({ key: 'fromPublic'}); + } catch(e) { + failed = true; + expect(e.code).toBe(Parse.Error.SESSION_MISSING); + } + expect({ failed }).toEqual({ failed: true }); + + // Try to save with a random user, should fail + failed = false; + const anyUser = new Parse.User(); + await anyUser.signUp({ + username: 'randomUser', + password: 'password' + }); + try { + await user.save({ key: 'fromAnyUser'}); + } catch(e) { + failed = true; + expect(e.code).toBe(Parse.Error.SESSION_MISSING); + } + expect({ failed }).toEqual({ failed: true }); + }); + it("current user", (done) => { const user = new Parse.User(); user.set("password", "asdf"); @@ -1722,7 +1888,7 @@ describe('Parse.User testing', () => { }); }); - it('should fail linking with existing', (done) => { + it('should fail linking with existing through REST', (done) => { const provider = getMockFacebookProvider(); Parse.User._registerAuthenticationProvider(provider); Parse.User._logInWith("facebook", { @@ -2278,7 +2444,7 @@ describe('Parse.User testing', () => { }, (error, response, body) => { expect(error).toBe(null); const b = JSON.parse(body); - expect(b.error).toBe('invalid session token'); + expect(b.error).toBe('Invalid session token'); request.put({ headers: { 'X-Parse-Application-Id': 'test', @@ -2370,7 +2536,7 @@ describe('Parse.User testing', () => { expect(error).toBe(null); const b = JSON.parse(body); expect(b.code).toEqual(209); - expect(b.error).toBe('invalid session token'); + expect(b.error).toBe('Invalid session token'); done(); }); }); @@ -2412,7 +2578,7 @@ describe('Parse.User testing', () => { }, (error,response,body) => { const b = JSON.parse(body); expect(b.code).toEqual(209); - expect(b.error).toBe('invalid session token'); + expect(b.error).toBe('Invalid session token'); done(); }); }); @@ -2449,7 +2615,7 @@ describe('Parse.User testing', () => { done(); }, function(err) { expect(err.code).toBe(Parse.Error.INVALID_SESSION_TOKEN); - expect(err.message).toBe('invalid session token'); + expect(err.message).toBe('Invalid session token'); done(); }); }); @@ -2525,7 +2691,7 @@ describe('Parse.User testing', () => { }); }); - it("invalid session tokens are rejected", (done) => { + it("Invalid session tokens are rejected", (done) => { Parse.User.signUp("asdf", "zxcv", null, { success: function() { request.get({ @@ -2538,7 +2704,7 @@ describe('Parse.User testing', () => { }, }, (error, response, body) => { expect(body.code).toBe(209); - expect(body.error).toBe('invalid session token'); + expect(body.error).toBe('Invalid session token'); done(); }) } @@ -3515,14 +3681,18 @@ describe('Parse.User testing', () => { email: 'yo@lo.com' }).then(() => { const token = user.getSessionToken(); - const promises = []; - while(promises.length != 5) { - promises.push(Parse.User.logIn('yolo', 'yolo').then((res) => { - // ensure a new session token is generated at each login - expect(res.getSessionToken()).not.toBe(token); - })); - } - return Promise.all(promises); + let promise = Promise.resolve(); + let count = 0; + while(count < 5) { + promise = promise.then(() => { + return Parse.User.logIn('yolo', 'yolo').then((res) => { + // ensure a new session token is generated at each login + expect(res.getSessionToken()).not.toBe(token); + }); + }); + count++; + } + return promise; }).then(() => { // wait because session destruction is not synchronous return new Promise((resolve) => { @@ -3536,4 +3706,36 @@ describe('Parse.User testing', () => { expect(results.length).toBe(1); }).then(done, done.fail); }); + + describe('issue #4897', () => { + it_only_db('mongo')("should be able to login with a legacy user (no ACL)", async () => { + // This issue is a side effect of the locked users and legacy users which don't have ACL's + // In this scenario, a legacy user wasn't be able to login as there's no ACL on it + const database = Config.get(Parse.applicationId).database; + const collection = await database.adapter._adaptiveCollection('_User'); + await collection.insertOne({ + "_id": "ABCDEF1234", + "name": "", + "email": "", + "username": "", + "_hashed_password": "", + "_auth_data_facebook": { + "id": "8675309", + "access_token": "jenny" + }, + "sessionToken": "", + }); + const provider = getMockFacebookProvider(); + Parse.User._registerAuthenticationProvider(provider); + const model = await Parse.User._logInWith("facebook", {}); + expect(model.id).toBe('ABCDEF1234'); + ok(model instanceof Parse.User, "Model should be a Parse.User"); + strictEqual(Parse.User.current(), model); + ok(model.extended(), "Should have used subclass."); + strictEqual(provider.authData.id, provider.synchronizedUserId); + strictEqual(provider.authData.access_token, provider.synchronizedAuthToken); + strictEqual(provider.authData.expiration_date, provider.synchronizedExpiration); + ok(model._isLinked("facebook"), "User should be linked to facebook"); + }); + }); }); diff --git a/spec/ParseWebSocket.spec.js b/spec/ParseWebSocket.spec.js index bd61807a01..b72dd28434 100644 --- a/spec/ParseWebSocket.spec.js +++ b/spec/ParseWebSocket.spec.js @@ -1,4 +1,4 @@ -const ParseWebSocket = require('../src/LiveQuery/ParseWebSocketServer').ParseWebSocket; +const ParseWebSocket = require('../lib/LiveQuery/ParseWebSocketServer').ParseWebSocket; describe('ParseWebSocket', function() { diff --git a/spec/ParseWebSocketServer.spec.js b/spec/ParseWebSocketServer.spec.js index a16f6a0104..b1b1ae5ad8 100644 --- a/spec/ParseWebSocketServer.spec.js +++ b/spec/ParseWebSocketServer.spec.js @@ -1,4 +1,4 @@ -const ParseWebSocketServer = require('../src/LiveQuery/ParseWebSocketServer').ParseWebSocketServer; +const ParseWebSocketServer = require('../lib/LiveQuery/ParseWebSocketServer').ParseWebSocketServer; describe('ParseWebSocketServer', function() { diff --git a/spec/PointerPermissions.spec.js b/spec/PointerPermissions.spec.js index 32830059bc..5c83365062 100644 --- a/spec/PointerPermissions.spec.js +++ b/spec/PointerPermissions.spec.js @@ -1,5 +1,5 @@ 'use strict'; -const Config = require('../src/Config'); +const Config = require('../lib/Config'); describe('Pointer Permissions', () => { diff --git a/spec/PostgresConfigParser.spec.js b/spec/PostgresConfigParser.spec.js index 0d41f320b5..4b966b1e2a 100644 --- a/spec/PostgresConfigParser.spec.js +++ b/spec/PostgresConfigParser.spec.js @@ -1,4 +1,4 @@ -const parser = require('../src/Adapters/Storage/Postgres/PostgresConfigParser'); +const parser = require('../lib/Adapters/Storage/Postgres/PostgresConfigParser'); const queryParamTests = { 'a=1&b=2': { a: '1', b: '2' }, diff --git a/spec/PostgresInitOptions.spec.js b/spec/PostgresInitOptions.spec.js index 1297963ad3..f870b3b7de 100644 --- a/spec/PostgresInitOptions.spec.js +++ b/spec/PostgresInitOptions.spec.js @@ -1,27 +1,19 @@ const Parse = require('parse/node').Parse; -import PostgresStorageAdapter from '../src/Adapters/Storage/Postgres/PostgresStorageAdapter'; +const PostgresStorageAdapter = require('../lib/Adapters/Storage/Postgres/PostgresStorageAdapter').default; const postgresURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database'; -const ParseServer = require("../src/index"); +const ParseServer = require("../lib/index"); const express = require('express'); //public schema const databaseOptions1 = { initOptions: { - connect: function (client, dc, isFresh) { - if (isFresh) { - client.query('SET search_path = public'); - } - } + schema: 'public' } }; //not exists schema const databaseOptions2 = { initOptions: { - connect: function (client, dc, isFresh) { - if (isFresh) { - client.query('SET search_path = not_exists_schema'); - } - } + schema: 'not_exists_schema' } }; diff --git a/spec/PostgresStorageAdapter.spec.js b/spec/PostgresStorageAdapter.spec.js index 1ba24f6515..d54cb9f2a8 100644 --- a/spec/PostgresStorageAdapter.spec.js +++ b/spec/PostgresStorageAdapter.spec.js @@ -1,4 +1,4 @@ -import PostgresStorageAdapter from '../src/Adapters/Storage/Postgres/PostgresStorageAdapter'; +const PostgresStorageAdapter = require('../lib/Adapters/Storage/Postgres/PostgresStorageAdapter').default; const databaseURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database'; const getColumns = (client, className) => { diff --git a/spec/PromiseRouter.spec.js b/spec/PromiseRouter.spec.js index d0ce63b0eb..7dc0b1a234 100644 --- a/spec/PromiseRouter.spec.js +++ b/spec/PromiseRouter.spec.js @@ -1,4 +1,4 @@ -const PromiseRouter = require("../src/PromiseRouter").default; +const PromiseRouter = require("../lib/PromiseRouter").default; describe("PromiseRouter", () => { it("should properly handle rejects", (done) => { diff --git a/spec/PushController.spec.js b/spec/PushController.spec.js index 60dc4619b4..059f0d6632 100644 --- a/spec/PushController.spec.js +++ b/spec/PushController.spec.js @@ -1,8 +1,8 @@ "use strict"; -const PushController = require('../src/Controllers/PushController').PushController; -const StatusHandler = require('../src/StatusHandler'); -const Config = require('../src/Config'); -const validatePushType = require('../src/Push/utils').validatePushType; +const PushController = require('../lib/Controllers/PushController').PushController; +const StatusHandler = require('../lib/StatusHandler'); +const Config = require('../lib/Config'); +const validatePushType = require('../lib/Push/utils').validatePushType; const successfulTransmissions = function(body, installations) { @@ -245,6 +245,84 @@ describe('PushController', () => { }); }); + it('properly increment badges by more than 1', (done) => { + const pushAdapter = { + send: function(body, installations) { + const badge = body.data.badge; + installations.forEach((installation) => { + expect(installation.badge).toEqual(badge); + expect(installation.originalBadge + 3).toEqual(installation.badge); + }) + return successfulTransmissions(body, installations); + }, + getValidPushTypes: function() { + return ["ios", "android"]; + } + } + const payload = {data:{ + alert: "Hello World!", + badge: { __op: 'Increment', amount: 3 }, + }} + const installations = []; + while(installations.length != 10) { + const installation = new Parse.Object("_Installation"); + installation.set("installationId", "installation_" + installations.length); + installation.set("deviceToken","device_token_" + installations.length) + installation.set("badge", installations.length); + installation.set("originalBadge", installations.length); + installation.set("deviceType", "ios"); + installations.push(installation); + } + + while(installations.length != 15) { + const installation = new Parse.Object("_Installation"); + installation.set("installationId", "installation_" + installations.length); + installation.set("deviceToken","device_token_" + installations.length); + installation.set("badge", installations.length); + installation.set("originalBadge", installations.length); + installation.set("deviceType", "android"); + installations.push(installation); + } + const config = Config.get(Parse.applicationId); + const auth = { + isMaster: true + } + + const pushController = new PushController(); + reconfigureServer({ + push: { adapter: pushAdapter } + }).then(() => { + return Parse.Object.saveAll(installations) + }).then(() => { + return pushController.sendPush(payload, {}, config, auth); + }).then(() => { + // Wait so the push is completed. + return new Promise((resolve) => { setTimeout(() => { resolve(); }, 1000); }); + }).then(() => { + // Check we actually sent 15 pushes. + const query = new Parse.Query('_PushStatus'); + return query.find({ useMasterKey: true }) + }).then((results) => { + expect(results.length).toBe(1); + const pushStatus = results[0]; + expect(pushStatus.get('numSent')).toBe(15); + }).then(() => { + // Check that the installations were actually updated. + const query = new Parse.Query('_Installation'); + return query.find({ useMasterKey: true }) + }).then((results) => { + expect(results.length).toBe(15); + for (let i = 0; i < 15; i++) { + const installation = results[i]; + expect(installation.get('badge')).toBe(parseInt(installation.get('originalBadge')) + 3); + } + done() + }).catch((err) => { + jfail(err); + done(); + }); + }); + it('properly set badges to 1', (done) => { const pushAdapter = { diff --git a/spec/PushQueue.spec.js b/spec/PushQueue.spec.js index 3e9aedae98..1bf282203d 100644 --- a/spec/PushQueue.spec.js +++ b/spec/PushQueue.spec.js @@ -1,5 +1,5 @@ -import Config from "../src/Config"; -import {PushQueue} from "../src/Push/PushQueue"; +const Config = require("../lib/Config"); +const {PushQueue} = require("../lib/Push/PushQueue"); describe('PushQueue', () => { describe('With a defined channel', () => { diff --git a/spec/PushRouter.spec.js b/spec/PushRouter.spec.js index 6a942498ea..70781fc137 100644 --- a/spec/PushRouter.spec.js +++ b/spec/PushRouter.spec.js @@ -1,4 +1,4 @@ -const PushRouter = require('../src/Routers/PushRouter').PushRouter; +const PushRouter = require('../lib/Routers/PushRouter').PushRouter; const request = require('request'); describe('PushRouter', () => { diff --git a/spec/PushWorker.spec.js b/spec/PushWorker.spec.js index 43d49ac5bc..9234a28d77 100644 --- a/spec/PushWorker.spec.js +++ b/spec/PushWorker.spec.js @@ -1,8 +1,8 @@ -const PushWorker = require('../src').PushWorker; -const PushUtils = require('../src/Push/utils'); -const Config = require('../src/Config'); -const { pushStatusHandler } = require('../src/StatusHandler'); -const rest = require('../src/rest'); +const PushWorker = require('../lib').PushWorker; +const PushUtils = require('../lib/Push/utils'); +const Config = require('../lib/Config'); +const { pushStatusHandler } = require('../lib/StatusHandler'); +const rest = require('../lib/rest'); describe('PushWorker', () => { it('should run with small batch', (done) => { @@ -90,6 +90,10 @@ describe('PushWorker', () => { expect(locales).toEqual(['fr']); }); + it('should handle empty body data', () => { + expect(PushUtils.getLocalesFromPush({})).toEqual([]); + }); + it('transforms body appropriately', () => { const cleanBody = PushUtils.transformPushBodyForLocale({ data: { diff --git a/spec/QueryTools.spec.js b/spec/QueryTools.spec.js index 7069725214..9c5acf1f73 100644 --- a/spec/QueryTools.spec.js +++ b/spec/QueryTools.spec.js @@ -1,7 +1,7 @@ const Parse = require('parse/node'); -const Id = require('../src/LiveQuery/Id'); -const QueryTools = require('../src/LiveQuery/QueryTools'); +const Id = require('../lib/LiveQuery/Id'); +const QueryTools = require('../lib/LiveQuery/QueryTools'); const queryHash = QueryTools.queryHash; const matchesQuery = QueryTools.matchesQuery; diff --git a/spec/ReadPreferenceOption.spec.js b/spec/ReadPreferenceOption.spec.js index c25dec0f01..bfbc1525fd 100644 --- a/spec/ReadPreferenceOption.spec.js +++ b/spec/ReadPreferenceOption.spec.js @@ -3,7 +3,7 @@ const Parse = require('parse/node'); const ReadPreference = require('mongodb').ReadPreference; const rp = require('request-promise'); -const Config = require("../src/Config"); +const Config = require("../lib/Config"); describe_only_db('mongo')('Read preference option', () => { it('should find in primary by default', (done) => { @@ -27,17 +27,56 @@ describe_only_db('mongo')('Read preference option', () => { let myObjectReadPreference = null; databaseAdapter.database.serverConfig.cursor.calls.all().forEach((call) => { if (call.args[0].indexOf('MyObject') >= 0) { - myObjectReadPreference = call.args[2].readPreference.preference; + myObjectReadPreference = true; + expect(call.args[2].readPreference.preference).toBe(ReadPreference.PRIMARY); } }); - expect(myObjectReadPreference).toEqual(ReadPreference.PRIMARY); + expect(myObjectReadPreference).toBe(true); done(); }); }); }); + it('should preserve the read preference set (#4831)', async () => { + const { MongoStorageAdapter } = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter'); + const adapterOptions = { + uri: 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase', + mongoOptions: { + readPreference: ReadPreference.NEAREST, + } + }; + await reconfigureServer({ databaseAdapter: new MongoStorageAdapter(adapterOptions) }); + + const databaseAdapter = (Config.get(Parse.applicationId)).database.adapter; + + const obj0 = new Parse.Object('MyObject'); + obj0.set('boolKey', false); + const obj1 = new Parse.Object('MyObject'); + obj1.set('boolKey', true); + + await Parse.Object.saveAll([obj0, obj1]) + spyOn(databaseAdapter.database.serverConfig, 'cursor').and.callThrough(); + + const query = new Parse.Query('MyObject'); + query.equalTo('boolKey', false); + + const results = await query.find(); + expect(results.length).toBe(1); + expect(results[0].get('boolKey')).toBe(false); + + let myObjectReadPreference = null; + databaseAdapter.database.serverConfig.cursor.calls.all().forEach((call) => { + if (call.args[0].indexOf('MyObject') >= 0) { + myObjectReadPreference = true; + expect(call.args[2].readPreference.preference).toBe(ReadPreference.NEAREST); + } + }); + + expect(myObjectReadPreference).toBe(true); + }); + it('should change read preference in the beforeFind trigger', (done) => { const databaseAdapter = (Config.get(Parse.applicationId)).database.adapter; @@ -442,18 +481,20 @@ describe_only_db('mongo')('Read preference option', () => { let myObjectReadPreference2 = null; databaseAdapter.database.serverConfig.cursor.calls.all().forEach((call) => { if (call.args[0].indexOf('MyObject0') >= 0) { - myObjectReadPreference0 = call.args[2].readPreference.preference; + myObjectReadPreference0 = true; + expect(call.args[2].readPreference.preference).toBe(ReadPreference.PRIMARY); } if (call.args[0].indexOf('MyObject1') >= 0) { - myObjectReadPreference1 = call.args[2].readPreference.preference; + myObjectReadPreference1 = true; + expect(call.args[2].readPreference.preference).toBe(ReadPreference.PRIMARY); } if (call.args[0].indexOf('MyObject2') >= 0) { myObjectReadPreference2 = call.args[2].readPreference.preference; } }); - expect(myObjectReadPreference0).toEqual(ReadPreference.PRIMARY); - expect(myObjectReadPreference1).toEqual(ReadPreference.PRIMARY); + expect(myObjectReadPreference0).toBe(true); + expect(myObjectReadPreference1).toBe(true); expect(myObjectReadPreference2).toEqual(ReadPreference.SECONDARY); done(); @@ -555,18 +596,20 @@ describe_only_db('mongo')('Read preference option', () => { let myObjectReadPreference2 = null; databaseAdapter.database.serverConfig.cursor.calls.all().forEach((call) => { if (call.args[0].indexOf('MyObject0') >= 0) { - myObjectReadPreference0 = call.args[2].readPreference.preference; + myObjectReadPreference0 = true; + expect(call.args[2].readPreference.preference).toBe(ReadPreference.PRIMARY); } if (call.args[0].indexOf('MyObject1') >= 0) { - myObjectReadPreference1 = call.args[2].readPreference.preference; + myObjectReadPreference1 = true; + expect(call.args[2].readPreference.preference).toBe(ReadPreference.PRIMARY); } if (call.args[0].indexOf('MyObject2') >= 0) { myObjectReadPreference2 = call.args[2].readPreference.preference; } }); - expect(myObjectReadPreference0).toEqual(ReadPreference.PRIMARY); - expect(myObjectReadPreference1).toEqual(ReadPreference.PRIMARY); + expect(myObjectReadPreference0).toBe(true); + expect(myObjectReadPreference1).toBe(true); expect(myObjectReadPreference2).toEqual(ReadPreference.SECONDARY); done(); diff --git a/spec/RedisCacheAdapter.spec.js b/spec/RedisCacheAdapter.spec.js index 4669d341a3..956e342701 100644 --- a/spec/RedisCacheAdapter.spec.js +++ b/spec/RedisCacheAdapter.spec.js @@ -1,4 +1,4 @@ -const RedisCacheAdapter = require('../src/Adapters/Cache/RedisCacheAdapter').default; +const RedisCacheAdapter = require('../lib/Adapters/Cache/RedisCacheAdapter').default; /* To run this test part of the complete suite set PARSE_SERVER_TEST_CACHE='redis' diff --git a/spec/RedisPubSub.spec.js b/spec/RedisPubSub.spec.js index 32497b576b..8530a95c0c 100644 --- a/spec/RedisPubSub.spec.js +++ b/spec/RedisPubSub.spec.js @@ -1,4 +1,4 @@ -const RedisPubSub = require('../src/Adapters/PubSub/RedisPubSub').RedisPubSub; +const RedisPubSub = require('../lib/Adapters/PubSub/RedisPubSub').RedisPubSub; describe('RedisPubSub', function() { diff --git a/spec/RestQuery.spec.js b/spec/RestQuery.spec.js index 5d1c888163..1b39af2ba8 100644 --- a/spec/RestQuery.spec.js +++ b/spec/RestQuery.spec.js @@ -1,8 +1,8 @@ 'use strict' // These tests check the "find" functionality of the REST API. -const auth = require('../src/Auth'); -const Config = require('../src/Config'); -const rest = require('../src/rest'); +const auth = require('../lib/Auth'); +const Config = require('../lib/Config'); +const rest = require('../lib/rest'); const querystring = require('querystring'); const rp = require('request-promise'); diff --git a/spec/RevocableSessionsUpgrade.spec.js b/spec/RevocableSessionsUpgrade.spec.js index f9d87536bd..8b546695a8 100644 --- a/spec/RevocableSessionsUpgrade.spec.js +++ b/spec/RevocableSessionsUpgrade.spec.js @@ -1,4 +1,4 @@ -const Config = require('../src/Config'); +const Config = require('../lib/Config'); const sessionToken = 'legacySessionToken'; const rp = require('request-promise'); const Parse = require('parse/node'); diff --git a/spec/Schema.spec.js b/spec/Schema.spec.js index c00f930c6c..c2f738e693 100644 --- a/spec/Schema.spec.js +++ b/spec/Schema.spec.js @@ -1,7 +1,7 @@ 'use strict'; -const Config = require('../src/Config'); -const SchemaController = require('../src/Controllers/SchemaController'); +const Config = require('../lib/Config'); +const SchemaController = require('../lib/Controllers/SchemaController'); const dd = require('deep-diff'); let config; diff --git a/spec/SchemaCache.spec.js b/spec/SchemaCache.spec.js index ffbe918399..7d4e54b09c 100644 --- a/spec/SchemaCache.spec.js +++ b/spec/SchemaCache.spec.js @@ -1,6 +1,6 @@ -const CacheController = require('../src/Controllers/CacheController.js').default; -const InMemoryCacheAdapter = require('../src/Adapters/Cache/InMemoryCacheAdapter').default; -const SchemaCache = require('../src/Controllers/SchemaCache').default; +const CacheController = require('../lib/Controllers/CacheController.js').default; +const InMemoryCacheAdapter = require('../lib/Adapters/Cache/InMemoryCacheAdapter').default; +const SchemaCache = require('../lib/Controllers/SchemaCache').default; describe('SchemaCache', () => { let cacheController; diff --git a/spec/SessionTokenCache.spec.js b/spec/SessionTokenCache.spec.js index 316e55da63..9e230116fb 100644 --- a/spec/SessionTokenCache.spec.js +++ b/spec/SessionTokenCache.spec.js @@ -1,4 +1,4 @@ -const SessionTokenCache = require('../src/LiveQuery/SessionTokenCache').SessionTokenCache; +const SessionTokenCache = require('../lib/LiveQuery/SessionTokenCache').SessionTokenCache; describe('SessionTokenCache', function() { diff --git a/spec/Subscription.spec.js b/spec/Subscription.spec.js index 9fe20179b1..0d06ef304f 100644 --- a/spec/Subscription.spec.js +++ b/spec/Subscription.spec.js @@ -1,9 +1,9 @@ -const Subscription = require('../src/LiveQuery/Subscription').Subscription; +const Subscription = require('../lib/LiveQuery/Subscription').Subscription; let logger; describe('Subscription', function() { beforeEach(function() { - logger = require('../src/logger').logger; + logger = require('../lib/logger').logger; spyOn(logger, 'error').and.callThrough(); }); diff --git a/spec/TwitterAuth.spec.js b/spec/TwitterAuth.spec.js index d98297f745..4845bde7ad 100644 --- a/spec/TwitterAuth.spec.js +++ b/spec/TwitterAuth.spec.js @@ -1,4 +1,4 @@ -const twitter = require('../src/Adapters/Auth/twitter'); +const twitter = require('../lib/Adapters/Auth/twitter'); describe('Twitter Auth', () => { it('should use the proper configuration', () => { diff --git a/spec/Uniqueness.spec.js b/spec/Uniqueness.spec.js index 0789037953..25394cafcf 100644 --- a/spec/Uniqueness.spec.js +++ b/spec/Uniqueness.spec.js @@ -1,7 +1,7 @@ 'use strict'; const Parse = require("parse/node"); -const Config = require('../src/Config'); +const Config = require('../lib/Config'); describe('Uniqueness', function() { it('fail when create duplicate value in unique field', done => { diff --git a/spec/UserController.spec.js b/spec/UserController.spec.js index 4588091f15..0b55346d40 100644 --- a/spec/UserController.spec.js +++ b/spec/UserController.spec.js @@ -1,6 +1,6 @@ -const UserController = require('../src/Controllers/UserController').UserController; +const UserController = require('../lib/Controllers/UserController').UserController; const emailAdapter = require('./MockEmailAdapter') -const AppCache = require('../src/cache').AppCache; +const AppCache = require('../lib/cache').AppCache; describe('UserController', () => { const user = { diff --git a/spec/UserPII.spec.js b/spec/UserPII.spec.js index ef0ebe0946..f581f5a4a6 100644 --- a/spec/UserPII.spec.js +++ b/spec/UserPII.spec.js @@ -3,7 +3,7 @@ const Parse = require('parse/node'); const request = require('request-promise'); -// const Config = require('../src/Config'); +// const Config = require('../lib/Config'); const EMAIL = 'foo@bar.com'; const ZIP = '10001'; diff --git a/spec/ValidationAndPasswordsReset.spec.js b/spec/ValidationAndPasswordsReset.spec.js index 99367a0bbd..3cc1b1a2fe 100644 --- a/spec/ValidationAndPasswordsReset.spec.js +++ b/spec/ValidationAndPasswordsReset.spec.js @@ -2,7 +2,7 @@ const MockEmailAdapterWithOptions = require('./MockEmailAdapterWithOptions'); const request = require('request'); -const Config = require("../src/Config"); +const Config = require("../lib/Config"); describe("Custom Pages, Email Verification, Password Reset", () => { it("should set the custom pages", (done) => { diff --git a/spec/VerifyUserPassword.spec.js b/spec/VerifyUserPassword.spec.js new file mode 100644 index 0000000000..28bd7c38c3 --- /dev/null +++ b/spec/VerifyUserPassword.spec.js @@ -0,0 +1,494 @@ +"use strict"; + +const rp = require('request-promise'); +const MockEmailAdapterWithOptions = require('./MockEmailAdapterWithOptions'); + +const verifyPassword = function (login, password, isEmail = false) { + const body = (!isEmail) ? { username: login, password } : { email: login, password }; + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + body, + json: true + }).then((res) => res) + .catch((err) => err); +}; + +const isAccountLockoutError = function (username, password, duration, waitTime) { + return new Promise((resolve, reject) => { + setTimeout(() => { + Parse.User.logIn(username, password) + .then(() => reject('login should have failed')) + .catch(err => { + if (err.message === 'Your account is locked due to multiple failed login attempts. Please try again after ' + duration + ' minute(s)') { + resolve(); + } else { + reject(err); + } + }); + }, waitTime); + }); +}; + +describe("Verify User Password", () => { + it('fails to verify password when masterKey has locked out user', (done) => { + const user = new Parse.User(); + const ACL = new Parse.ACL(); + ACL.setPublicReadAccess(false); + ACL.setPublicWriteAccess(false); + user.setUsername('testuser'); + user.setPassword('mypass'); + user.setACL(ACL); + user.signUp().then(() => { + return Parse.User.logIn('testuser', 'mypass'); + }).then((user) => { + equal(user.get('username'), 'testuser'); + // Lock the user down + const ACL = new Parse.ACL(); + user.setACL(ACL); + return user.save(null, { useMasterKey: true }); + }).then(() => { + expect(user.getACL().getPublicReadAccess()).toBe(false); + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + qs: { + username: 'testuser', + password: 'mypass', + } + }); + }).then((res) => { + fail(res); + done(); + }).catch((err) => { + expect(err.statusCode).toBe(404); + expect(err.error).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }); + }); + it('fails to verify password when username is not provided in query string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + qs: { + username: '', + password: 'mypass', + } + }); + }).then((res) => { + fail(res); + done(); + }).catch((err) => { + expect(err.statusCode).toBe(400); + expect(err.error).toMatch('{"code":200,"error":"username/email is required."}'); + done(); + }); + }); + it('fails to verify password when email is not provided in query string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + qs: { + email: '', + password: 'mypass', + } + }); + }).then((res) => { + fail(res); + done(); + }).catch((err) => { + expect(err.statusCode).toBe(400); + expect(err.error).toMatch('{"code":200,"error":"username/email is required."}'); + done(); + }); + }); + it('fails to verify password when username is not provided with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('', 'mypass'); + }).then((res) => { + expect(res.statusCode).toBe(400); + expect(JSON.stringify(res.error)).toMatch('{"code":200,"error":"username/email is required."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when email is not provided with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('', 'mypass', true); + }).then((res) => { + expect(res.statusCode).toBe(400); + expect(JSON.stringify(res.error)).toMatch('{"code":200,"error":"username/email is required."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when password is not provided with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('testuser', ''); + }).then((res) => { + expect(res.statusCode).toBe(400); + expect(JSON.stringify(res.error)).toMatch('{"code":201,"error":"password is required."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when username matches but password does not match hash with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('testuser', 'wrong password'); + }).then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when email matches but password does not match hash with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('my@user.com', 'wrong password', true); + }).then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when typeof username does not equal string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword(123, 'mypass'); + }).then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when typeof email does not equal string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword(123, 'mypass', true); + }).then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when typeof password does not equal string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('my@user.com', 123, true); + }).then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when username cannot be found REST API', (done) => { + verifyPassword('mytestuser', 'mypass') + .then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when email cannot be found REST API', (done) => { + verifyPassword('my@user.com', 'mypass', true) + .then((res) => { + expect(res.statusCode).toBe(404); + expect(JSON.stringify(res.error)).toMatch('{"code":101,"error":"Invalid username/password."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('fails to verify password when preventLoginWithUnverifiedEmail is set to true REST API', (done) => { + reconfigureServer({ + publicServerURL: "http://localhost:8378/", + appName: 'emailVerify', + verifyUserEmails: true, + preventLoginWithUnverifiedEmail: true, + emailAdapter: MockEmailAdapterWithOptions({ + fromAddress: 'parse@example.com', + apiKey: 'k', + domain: 'd', + }), + }).then(() => { + const user = new Parse.User(); + return user.save({ + username: 'unverified-user', + password: 'mypass', + email: 'unverified-email@user.com' + }); + }).then(() => { + return verifyPassword('unverified-email@user.com', 'mypass', true); + }).then((res) => { + expect(res.statusCode).toBe(400); + expect(JSON.stringify(res.error)).toMatch('{"code":205,"error":"User email is not verified."}'); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('verify password lock account if failed verify password attempts are above threshold', done => { + reconfigureServer({ + appName: 'lockout threshold', + accountLockout: { + duration: 1, + threshold: 2 + }, + publicServerURL: "http://localhost:8378/" + }) + .then(() => { + const user = new Parse.User(); + return user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }) + }) + .then(() => { + return verifyPassword('testuser', 'wrong password'); + }) + .then(() => { + return verifyPassword('testuser', 'wrong password'); + }) + .then(() => { + return verifyPassword('testuser', 'wrong password'); + }) + .then(() => { + return isAccountLockoutError('testuser', 'wrong password', 1, 1); + }) + .then(() => { + done(); + }) + .catch(err => { + fail('lock account after failed login attempts test failed: ' + JSON.stringify(err)); + done(); + }); + }); + it('succeed in verifying password when username and email are provided and password matches hash with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + body: { + username: 'testuser', + email: 'my@user.com', + password: 'mypass' + }, + json: true + }).then((res) => res) + .catch((err) => err); + }).then((res) => { + expect(typeof res).toBe('object'); + expect(typeof res['objectId']).toEqual('string'); + expect(res.hasOwnProperty('sessionToken')).toEqual(false); + expect(res.hasOwnProperty('password')).toEqual(false); + done(); + }).catch((err) => { + fail(err); + done(); + }); + }); + it('succeed in verifying password when username and password matches hash with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('testuser', 'mypass'); + }).then((res) => { + expect(typeof res).toBe('object'); + expect(typeof res['objectId']).toEqual('string'); + expect(res.hasOwnProperty('sessionToken')).toEqual(false); + expect(res.hasOwnProperty('password')).toEqual(false); + done(); + }); + }); + it('succeed in verifying password when email and password matches hash with json payload REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return verifyPassword('my@user.com', 'mypass', true); + }).then((res) => { + expect(typeof res).toBe('object'); + expect(typeof res['objectId']).toEqual('string'); + expect(res.hasOwnProperty('sessionToken')).toEqual(false); + expect(res.hasOwnProperty('password')).toEqual(false); + done(); + }); + }); + it('succeed to verify password when username and password provided in query string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + qs: { + username: 'testuser', + password: 'mypass', + } + }); + }).then((res) => { + expect(typeof res).toBe('string'); + const body = JSON.parse(res); + expect(typeof body['objectId']).toEqual('string'); + expect(body.hasOwnProperty('sessionToken')).toEqual(false); + expect(body.hasOwnProperty('password')).toEqual(false); + done(); + }); + }); + it('succeed to verify password when email and password provided in query string REST API', (done) => { + const user = new Parse.User(); + user.save({ + username: 'testuser', + password: 'mypass', + email: 'my@user.com' + }).then(() => { + return rp.get({ + url: Parse.serverURL + '/verifyPassword', + headers: { + 'X-Parse-Application-Id': Parse.applicationId, + 'X-Parse-REST-API-Key': 'rest' + }, + qs: { + email: 'my@user.com', + password: 'mypass', + } + }); + }).then((res) => { + expect(typeof res).toBe('string'); + const body = JSON.parse(res); + expect(typeof body['objectId']).toEqual('string'); + expect(body.hasOwnProperty('sessionToken')).toEqual(false); + expect(body.hasOwnProperty('password')).toEqual(false); + done(); + }); + }); + it('succeed to verify password with username when user1 has username === user2 email REST API', (done) => { + const user1 = new Parse.User(); + user1.save({ + username: 'email@user.com', + password: 'mypass1', + email: '1@user.com' + }).then(() => { + const user2 = new Parse.User(); + return user2.save({ + username: 'user2', + password: 'mypass2', + email: 'email@user.com' + }); + }).then(() => { + return verifyPassword('email@user.com', 'mypass1'); + }).then((res) => { + expect(typeof res).toBe('object'); + expect(typeof res['objectId']).toEqual('string'); + expect(res.hasOwnProperty('sessionToken')).toEqual(false); + expect(res.hasOwnProperty('password')).toEqual(false); + done(); + }); + }); +}) diff --git a/spec/WinstonLoggerAdapter.spec.js b/spec/WinstonLoggerAdapter.spec.js index 555a3feeeb..da450b6388 100644 --- a/spec/WinstonLoggerAdapter.spec.js +++ b/spec/WinstonLoggerAdapter.spec.js @@ -1,6 +1,6 @@ 'use strict'; -const WinstonLoggerAdapter = require('../src/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; +const WinstonLoggerAdapter = require('../lib/Adapters/Logger/WinstonLoggerAdapter').WinstonLoggerAdapter; const request = require('request'); describe('info logs', () => { diff --git a/spec/batch.spec.js b/spec/batch.spec.js index b789b92b35..0cc36796ab 100644 --- a/spec/batch.spec.js +++ b/spec/batch.spec.js @@ -1,4 +1,4 @@ -const batch = require('../src/batch'); +const batch = require('../lib/batch'); const originalURL = '/parse/batch'; const serverURL = 'http://localhost:1234/parse'; diff --git a/spec/cryptoUtils.spec.js b/spec/cryptoUtils.spec.js index effa73b9fd..8270e052cf 100644 --- a/spec/cryptoUtils.spec.js +++ b/spec/cryptoUtils.spec.js @@ -1,4 +1,4 @@ -const cryptoUtils = require('../src/cryptoUtils'); +const cryptoUtils = require('../lib/cryptoUtils'); function givesUniqueResults(fn, iterations) { const results = {}; diff --git a/spec/helper.js b/spec/helper.js index 7b9c2153eb..adcee4494b 100644 --- a/spec/helper.js +++ b/spec/helper.js @@ -1,11 +1,11 @@ "use strict" // Sets up a Parse API server for testing. const SpecReporter = require('jasmine-spec-reporter').SpecReporter; - +const supportsColor = require('supports-color'); jasmine.DEFAULT_TIMEOUT_INTERVAL = process.env.PARSE_SERVER_TEST_TIMEOUT || 5000; jasmine.getEnv().clearReporters(); -jasmine.getEnv().addReporter(new SpecReporter()); +jasmine.getEnv().addReporter(new SpecReporter({ colors: { enabled: supportsColor.stdout }, spec: { displayDuration: true }})); global.on_db = (db, callback, elseCallback) => { if (process.env.PARSE_SERVER_TEST_DB == db) { @@ -23,15 +23,15 @@ if (global._babelPolyfill) { process.exit(1); } -const cache = require('../src/cache').default; -const ParseServer = require('../src/index').ParseServer; +const cache = require('../lib/cache').default; +const ParseServer = require('../lib/index').ParseServer; const path = require('path'); -const TestUtils = require('../src/TestUtils'); -const GridStoreAdapter = require('../src/Adapters/Files/GridStoreAdapter').GridStoreAdapter; +const TestUtils = require('../lib/TestUtils'); +const GridStoreAdapter = require('../lib/Adapters/Files/GridStoreAdapter').GridStoreAdapter; const FSAdapter = require('@parse/fs-files-adapter'); -import PostgresStorageAdapter from '../src/Adapters/Storage/Postgres/PostgresStorageAdapter'; -import MongoStorageAdapter from '../src/Adapters/Storage/Mongo/MongoStorageAdapter'; -const RedisCacheAdapter = require('../src/Adapters/Cache/RedisCacheAdapter').default; +const PostgresStorageAdapter = require('../lib/Adapters/Storage/Postgres/PostgresStorageAdapter').default; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; +const RedisCacheAdapter = require('../lib/Adapters/Cache/RedisCacheAdapter').default; const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase'; const postgresURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database'; @@ -114,7 +114,6 @@ if (process.env.PARSE_SERVER_TEST_CACHE === 'redis') { } const openConnections = {}; - // Set up a default API server for testing with default configuration. let server; @@ -173,7 +172,7 @@ beforeEach(done => { throw error; } } - TestUtils.destroyAllDataPermanently() + TestUtils.destroyAllDataPermanently(true) .catch(error => { // For tests that connect to their own mongo, there won't be any data to delete. if (error.message === 'ns not found' || error.message.startsWith('connect ECONNREFUSED')) { @@ -197,7 +196,7 @@ afterEach(function(done) { fail('There were open connections to the server left after the test finished'); } on_db('postgres', () => { - TestUtils.destroyAllDataPermanently().then(done, done); + TestUtils.destroyAllDataPermanently(true).then(done, done); }, done); }; Parse.Cloud._removeAllHooks(); @@ -217,7 +216,14 @@ afterEach(function(done) { }); }) .then(() => Parse.User.logOut()) - .then(afterLogOut, afterLogOut) + .then(() => {}, () => {}) // swallow errors + .then(() => { + // Connection close events are not immediate on node 10+... wait a bit + return new Promise((resolve) => { + setTimeout(resolve, 0); + }); + }) + .then(afterLogOut) }); const TestObject = Parse.Object.extend({ @@ -287,11 +293,13 @@ function expectError(errorCode, callback) { error: function(obj, e) { // Some methods provide 2 parameters. e = e || obj; - if (!e) { - fail('expected a specific error but got a blank error'); - return; + if (errorCode !== undefined) { + if (!e) { + fail('expected a specific error but got a blank error'); + return; + } + expect(e.code).toEqual(errorCode, e.message); } - expect(e.code).toEqual(errorCode, e.message); if (callback) { callback(e); } @@ -410,7 +418,7 @@ global.it_exclude_dbs = excluded => { } global.it_only_db = db => { - if (process.env.PARSE_SERVER_TEST_DB === db) { + if (process.env.PARSE_SERVER_TEST_DB === db || !process.env.PARSE_SERVER_TEST_DB && db == 'mongo') { return it; } else { return xit; @@ -431,7 +439,7 @@ global.describe_only_db = db => { } else if (!process.env.PARSE_SERVER_TEST_DB && db == 'mongo') { return describe; } else { - return () => {}; + return xdescribe; } } diff --git a/spec/index.spec.js b/spec/index.spec.js index 335a8ac3fc..f962a4f06c 100644 --- a/spec/index.spec.js +++ b/spec/index.spec.js @@ -2,11 +2,11 @@ const request = require('request'); const parseServerPackage = require('../package.json'); const MockEmailAdapterWithOptions = require('./MockEmailAdapterWithOptions'); -const ParseServer = require("../src/index"); -const Config = require('../src/Config'); +const ParseServer = require("../lib/index"); +const Config = require('../lib/Config'); const express = require('express'); -import MongoStorageAdapter from '../src/Adapters/Storage/Mongo/MongoStorageAdapter'; +const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default; describe('server', () => { it('requires a master key and app id', done => { diff --git a/spec/parsers.spec.js b/spec/parsers.spec.js index e6313bb091..9249c0fa6f 100644 --- a/spec/parsers.spec.js +++ b/spec/parsers.spec.js @@ -1,4 +1,4 @@ -import { +const { numberParser, numberOrBoolParser, booleanParser, @@ -6,7 +6,7 @@ import { arrayParser, moduleOrObjectParser, nullParser, -} from '../src/Options/parsers'; +} = require('../lib/Options/parsers'); describe('parsers', () => { it('parses correctly with numberParser', () => { diff --git a/spec/rest.spec.js b/spec/rest.spec.js index af6ce8c41f..fae39b18e9 100644 --- a/spec/rest.spec.js +++ b/spec/rest.spec.js @@ -1,10 +1,10 @@ "use strict"; // These tests check the "create" / "update" functionality of the REST API. -const auth = require('../src/Auth'); -const Config = require('../src/Config'); +const auth = require('../lib/Auth'); +const Config = require('../lib/Config'); const Parse = require('parse/node').Parse; -const rest = require('../src/rest'); -const RestWrite = require('../src/RestWrite'); +const rest = require('../lib/rest'); +const RestWrite = require('../lib/RestWrite'); const request = require('request'); const rp = require('request-promise'); diff --git a/spec/schemas.spec.js b/spec/schemas.spec.js index a5a8256d84..e8ec3de67b 100644 --- a/spec/schemas.spec.js +++ b/spec/schemas.spec.js @@ -4,7 +4,7 @@ const Parse = require('parse/node').Parse; const request = require('request'); const rp = require('request-promise'); const dd = require('deep-diff'); -const Config = require('../src/Config'); +const Config = require('../lib/Config'); let config; @@ -262,21 +262,6 @@ describe('schemas', () => { }); }); - it('asks for the master key if you use the rest key', done => { - request.post({ - url: 'http://localhost:8378/1/schemas', - json: true, - headers: restKeyHeaders, - body: { - className: 'MyClass', - }, - }, (error, response, body) => { - expect(response.statusCode).toEqual(403); - expect(body.error).toEqual('unauthorized: master key is required'); - done(); - }); - }); - it('sends an error if you use mismatching class names', done => { request.post({ url: 'http://localhost:8378/1/schemas/A', @@ -1212,7 +1197,7 @@ describe('schemas', () => { }) }); - it('should throw with invalid * (spaces)', done => { + it('should throw with invalid * (spaces before)', done => { request.post({ url: 'http://localhost:8378/1/schemas/AClass', headers: masterKeyHeaders, @@ -1230,7 +1215,7 @@ describe('schemas', () => { }) }); - it('should throw with invalid * (spaces)', done => { + it('should throw with invalid * (spaces after)', done => { request.post({ url: 'http://localhost:8378/1/schemas/AClass', headers: masterKeyHeaders, @@ -1248,7 +1233,7 @@ describe('schemas', () => { }) }); - it('should throw with invalid value', done => { + it('should throw if permission is number', done => { request.post({ url: 'http://localhost:8378/1/schemas/AClass', headers: masterKeyHeaders, @@ -1266,7 +1251,7 @@ describe('schemas', () => { }) }); - it('should throw with invalid value', done => { + it('should throw if permission is empty string', done => { request.post({ url: 'http://localhost:8378/1/schemas/AClass', headers: masterKeyHeaders, @@ -1787,11 +1772,9 @@ describe('schemas', () => { 'delete': {}, 'addField': {}, }); - console.log(res); }).then(done).catch(done.fail); }); - it('regression test for #2246', done => { const profile = new Parse.Object('UserProfile'); const user = new Parse.User(); @@ -1828,133 +1811,89 @@ describe('schemas', () => { }); }); - it('cannot create index if field does not exist', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + describe('index management', () => { + beforeEach(() => require('../lib/TestUtils').destroyAllDataPermanently()); + it('cannot create index if field does not exist', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - indexes: { - name1: { aString: 1}, + body: {}, + }, () => { + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + name1: { aString: 1}, + } } - } - }, (error, response, body) => { - expect(body.code).toBe(Parse.Error.INVALID_QUERY); - expect(body.error).toBe('Field aString does not exist, cannot add index.'); - done(); - }); - }) - }); + }, (error, response, body) => { + expect(body.code).toBe(Parse.Error.INVALID_QUERY); + expect(body.error).toBe('Field aString does not exist, cannot add index.'); + done(); + }); + }) + }); - it('cannot create compound index if field does not exist', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + it('can create index on default field', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - fields: { - aString: {type: 'String'} - }, - indexes: { - name1: { aString: 1, bString: 1}, + body: {}, + }, () => { + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + name1: { createdAt: 1}, + } } - } - }, (error, response, body) => { - expect(body.code).toBe(Parse.Error.INVALID_QUERY); - expect(body.error).toBe('Field bString does not exist, cannot add index.'); - done(); - }); - }) - }); - - it('allows add index when you create a class', done => { - request.post({ - url: 'http://localhost:8378/1/schemas', - headers: masterKeyHeaders, - json: true, - body: { - className: "NewClass", - fields: { - aString: {type: 'String'} - }, - indexes: { - name1: { aString: 1}, - }, - } - }, (error, response, body) => { - expect(body).toEqual({ - className: 'NewClass', - fields: { - ACL: {type: 'ACL'}, - createdAt: {type: 'Date'}, - updatedAt: {type: 'Date'}, - objectId: {type: 'String'}, - aString: {type: 'String'} - }, - classLevelPermissions: defaultClassLevelPermissions, - indexes: { - name1: { aString: 1}, - }, - }); - config.database.adapter.getIndexes('NewClass').then((indexes) => { - expect(indexes.length).toBe(2); - done(); - }); + }, (error, response, body) => { + expect(body.indexes.name1).toEqual({ createdAt: 1}); + done(); + }); + }) }); - }); - it('empty index returns nothing', done => { - request.post({ - url: 'http://localhost:8378/1/schemas', - headers: masterKeyHeaders, - json: true, - body: { - className: "NewClass", - fields: { - aString: {type: 'String'} - }, - indexes: {}, - } - }, (error, response, body) => { - expect(body).toEqual({ - className: 'NewClass', - fields: { - ACL: {type: 'ACL'}, - createdAt: {type: 'Date'}, - updatedAt: {type: 'Date'}, - objectId: {type: 'String'}, - aString: {type: 'String'} - }, - classLevelPermissions: defaultClassLevelPermissions, - }); - done(); + it('cannot create compound index if field does not exist', done => { + request.post({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: {}, + }, () => { + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + fields: { + aString: {type: 'String'} + }, + indexes: { + name1: { aString: 1, bString: 1}, + } + } + }, (error, response, body) => { + expect(body.code).toBe(Parse.Error.INVALID_QUERY); + expect(body.error).toBe('Field bString does not exist, cannot add index.'); + done(); + }); + }) }); - }); - it('lets you add indexes', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ - url: 'http://localhost:8378/1/schemas/NewClass', + it('allows add index when you create a class', done => { + request.post({ + url: 'http://localhost:8378/1/schemas', headers: masterKeyHeaders, json: true, body: { + className: "NewClass", fields: { aString: {type: 'String'} }, @@ -1963,7 +1902,7 @@ describe('schemas', () => { }, } }, (error, response, body) => { - expect(dd(body, { + expect(body).toEqual({ className: 'NewClass', fields: { ACL: {type: 'ACL'}, @@ -1974,164 +1913,134 @@ describe('schemas', () => { }, classLevelPermissions: defaultClassLevelPermissions, indexes: { - _id_: { _id: 1 }, - name1: { aString: 1 }, - } - })).toEqual(undefined); - request.get({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - }, (error, response, body) => { - expect(body).toEqual({ - className: 'NewClass', - fields: { - ACL: {type: 'ACL'}, - createdAt: {type: 'Date'}, - updatedAt: {type: 'Date'}, - objectId: {type: 'String'}, - aString: {type: 'String'} - }, - classLevelPermissions: defaultClassLevelPermissions, - indexes: { - _id_: { _id: 1 }, - name1: { aString: 1 }, - } - }); - config.database.adapter.getIndexes('NewClass').then((indexes) => { - expect(indexes.length).toEqual(2); - done(); - }); + name1: { aString: 1}, + }, + }); + config.database.adapter.getIndexes('NewClass').then((indexes) => { + expect(indexes.length).toBe(2); + done(); }); }); - }) - }); + }); - it('lets you add multiple indexes', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ - url: 'http://localhost:8378/1/schemas/NewClass', + it('empty index returns nothing', done => { + request.post({ + url: 'http://localhost:8378/1/schemas', headers: masterKeyHeaders, json: true, body: { + className: "NewClass", fields: { - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - dString: {type: 'String'}, + aString: {type: 'String'} }, - indexes: { - name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1, dString: 1 }, - } + indexes: {}, } }, (error, response, body) => { - expect(dd(body, { + expect(body).toEqual({ className: 'NewClass', fields: { ACL: {type: 'ACL'}, createdAt: {type: 'Date'}, updatedAt: {type: 'Date'}, objectId: {type: 'String'}, - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - dString: {type: 'String'}, + aString: {type: 'String'} }, classLevelPermissions: defaultClassLevelPermissions, - indexes: { - _id_: { _id: 1 }, - name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1, dString: 1 }, - } - })).toEqual(undefined); - request.get({ + }); + done(); + }); + }); + + it('lets you add indexes', done => { + request.post({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: {}, + }, () => { + request.put({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, + body: { + fields: { + aString: {type: 'String'} + }, + indexes: { + name1: { aString: 1}, + }, + } }, (error, response, body) => { - expect(body).toEqual({ + expect(dd(body, { className: 'NewClass', fields: { ACL: {type: 'ACL'}, createdAt: {type: 'Date'}, updatedAt: {type: 'Date'}, objectId: {type: 'String'}, - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - dString: {type: 'String'}, + aString: {type: 'String'} }, classLevelPermissions: defaultClassLevelPermissions, indexes: { _id_: { _id: 1 }, name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1, dString: 1 }, - }, - }); - config.database.adapter.getIndexes('NewClass').then((indexes) => { - expect(indexes.length).toEqual(4); - done(); + } + })).toEqual(undefined); + request.get({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + }, (error, response, body) => { + expect(body).toEqual({ + className: 'NewClass', + fields: { + ACL: {type: 'ACL'}, + createdAt: {type: 'Date'}, + updatedAt: {type: 'Date'}, + objectId: {type: 'String'}, + aString: {type: 'String'} + }, + classLevelPermissions: defaultClassLevelPermissions, + indexes: { + _id_: { _id: 1 }, + name1: { aString: 1 }, + } + }); + config.database.adapter.getIndexes('NewClass').then((indexes) => { + expect(indexes.length).toEqual(2); + done(); + }); }); }); - }); - }) - }); + }) + }); - it('lets you delete indexes', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + it('lets you add multiple indexes', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - fields: { - aString: {type: 'String'}, - }, - indexes: { - name1: { aString: 1 }, - } - } - }, (error, response, body) => { - expect(dd(body, { - className: 'NewClass', - fields: { - ACL: {type: 'ACL'}, - createdAt: {type: 'Date'}, - updatedAt: {type: 'Date'}, - objectId: {type: 'String'}, - aString: {type: 'String'}, - }, - classLevelPermissions: defaultClassLevelPermissions, - indexes: { - _id_: { _id: 1 }, - name1: { aString: 1 }, - } - })).toEqual(undefined); + body: {}, + }, () => { request.put({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, body: { + fields: { + aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + dString: {type: 'String'}, + }, indexes: { - name1: { __op: 'Delete' } + name1: { aString: 1 }, + name2: { bString: 1 }, + name3: { cString: 1, dString: 1 }, } } }, (error, response, body) => { - expect(body).toEqual({ + expect(dd(body, { className: 'NewClass', fields: { ACL: {type: 'ACL'}, @@ -2139,76 +2048,145 @@ describe('schemas', () => { updatedAt: {type: 'Date'}, objectId: {type: 'String'}, aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + dString: {type: 'String'}, }, classLevelPermissions: defaultClassLevelPermissions, indexes: { _id_: { _id: 1 }, + name1: { aString: 1 }, + name2: { bString: 1 }, + name3: { cString: 1, dString: 1 }, } - }); - config.database.adapter.getIndexes('NewClass').then((indexes) => { - expect(indexes.length).toEqual(1); - done(); + })).toEqual(undefined); + request.get({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + }, (error, response, body) => { + expect(body).toEqual({ + className: 'NewClass', + fields: { + ACL: {type: 'ACL'}, + createdAt: {type: 'Date'}, + updatedAt: {type: 'Date'}, + objectId: {type: 'String'}, + aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + dString: {type: 'String'}, + }, + classLevelPermissions: defaultClassLevelPermissions, + indexes: { + _id_: { _id: 1 }, + name1: { aString: 1 }, + name2: { bString: 1 }, + name3: { cString: 1, dString: 1 }, + }, + }); + config.database.adapter.getIndexes('NewClass').then((indexes) => { + expect(indexes.length).toEqual(4); + done(); + }); }); }); - }); - }) - }); + }) + }); - it('lets you delete multiple indexes', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + it('lets you delete indexes', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - fields: { - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - }, - indexes: { - name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1 }, - } - } - }, (error, response, body) => { - expect(dd(body, { - className: 'NewClass', - fields: { - ACL: {type: 'ACL'}, - createdAt: {type: 'Date'}, - updatedAt: {type: 'Date'}, - objectId: {type: 'String'}, - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - }, - classLevelPermissions: defaultClassLevelPermissions, - indexes: { - _id_: { _id: 1 }, - name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1 }, + body: {}, + }, () => { + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + fields: { + aString: {type: 'String'}, + }, + indexes: { + name1: { aString: 1 }, + } } - })).toEqual(undefined); + }, (error, response, body) => { + expect(dd(body, { + className: 'NewClass', + fields: { + ACL: {type: 'ACL'}, + createdAt: {type: 'Date'}, + updatedAt: {type: 'Date'}, + objectId: {type: 'String'}, + aString: {type: 'String'}, + }, + classLevelPermissions: defaultClassLevelPermissions, + indexes: { + _id_: { _id: 1 }, + name1: { aString: 1 }, + } + })).toEqual(undefined); + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + name1: { __op: 'Delete' } + } + } + }, (error, response, body) => { + expect(body).toEqual({ + className: 'NewClass', + fields: { + ACL: {type: 'ACL'}, + createdAt: {type: 'Date'}, + updatedAt: {type: 'Date'}, + objectId: {type: 'String'}, + aString: {type: 'String'}, + }, + classLevelPermissions: defaultClassLevelPermissions, + indexes: { + _id_: { _id: 1 }, + } + }); + config.database.adapter.getIndexes('NewClass').then((indexes) => { + expect(indexes.length).toEqual(1); + done(); + }); + }); + }); + }) + }); + + it('lets you delete multiple indexes', done => { + request.post({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: {}, + }, () => { request.put({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, body: { + fields: { + aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + }, indexes: { - name1: { __op: 'Delete' }, - name2: { __op: 'Delete' }, + name1: { aString: 1 }, + name2: { bString: 1 }, + name3: { cString: 1 }, } } }, (error, response, body) => { - expect(body).toEqual({ + expect(dd(body, { className: 'NewClass', fields: { ACL: {type: 'ACL'}, @@ -2222,76 +2200,74 @@ describe('schemas', () => { classLevelPermissions: defaultClassLevelPermissions, indexes: { _id_: { _id: 1 }, + name1: { aString: 1 }, + name2: { bString: 1 }, name3: { cString: 1 }, } - }); - config.database.adapter.getIndexes('NewClass').then((indexes) => { - expect(indexes.length).toEqual(2); - done(); + })).toEqual(undefined); + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + name1: { __op: 'Delete' }, + name2: { __op: 'Delete' }, + } + } + }, (error, response, body) => { + expect(body).toEqual({ + className: 'NewClass', + fields: { + ACL: {type: 'ACL'}, + createdAt: {type: 'Date'}, + updatedAt: {type: 'Date'}, + objectId: {type: 'String'}, + aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + }, + classLevelPermissions: defaultClassLevelPermissions, + indexes: { + _id_: { _id: 1 }, + name3: { cString: 1 }, + } + }); + config.database.adapter.getIndexes('NewClass').then((indexes) => { + expect(indexes.length).toEqual(2); + done(); + }); }); }); - }); - }) - }); + }) + }); - it('lets you add and delete indexes', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + it('lets you add and delete indexes', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - fields: { - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - dString: {type: 'String'}, - }, - indexes: { - name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1 }, - } - } - }, (error, response, body) => { - expect(dd(body, { - className: 'NewClass', - fields: { - ACL: {type: 'ACL'}, - createdAt: {type: 'Date'}, - updatedAt: {type: 'Date'}, - objectId: {type: 'String'}, - aString: {type: 'String'}, - bString: {type: 'String'}, - cString: {type: 'String'}, - dString: {type: 'String'}, - }, - classLevelPermissions: defaultClassLevelPermissions, - indexes: { - _id_: { _id: 1 }, - name1: { aString: 1 }, - name2: { bString: 1 }, - name3: { cString: 1 }, - } - })).toEqual(undefined); + body: {}, + }, () => { request.put({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, body: { + fields: { + aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + dString: {type: 'String'}, + }, indexes: { - name1: { __op: 'Delete' }, - name2: { __op: 'Delete' }, - name4: { dString: 1 }, + name1: { aString: 1 }, + name2: { bString: 1 }, + name3: { cString: 1 }, } } }, (error, response, body) => { - expect(body).toEqual({ + expect(dd(body, { className: 'NewClass', fields: { ACL: {type: 'ACL'}, @@ -2306,150 +2282,183 @@ describe('schemas', () => { classLevelPermissions: defaultClassLevelPermissions, indexes: { _id_: { _id: 1 }, + name1: { aString: 1 }, + name2: { bString: 1 }, name3: { cString: 1 }, - name4: { dString: 1 }, } - }); - config.database.adapter.getIndexes('NewClass').then((indexes) => { - expect(indexes.length).toEqual(3); - done(); + })).toEqual(undefined); + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + name1: { __op: 'Delete' }, + name2: { __op: 'Delete' }, + name4: { dString: 1 }, + } + } + }, (error, response, body) => { + expect(body).toEqual({ + className: 'NewClass', + fields: { + ACL: {type: 'ACL'}, + createdAt: {type: 'Date'}, + updatedAt: {type: 'Date'}, + objectId: {type: 'String'}, + aString: {type: 'String'}, + bString: {type: 'String'}, + cString: {type: 'String'}, + dString: {type: 'String'}, + }, + classLevelPermissions: defaultClassLevelPermissions, + indexes: { + _id_: { _id: 1 }, + name3: { cString: 1 }, + name4: { dString: 1 }, + } + }); + config.database.adapter.getIndexes('NewClass').then((indexes) => { + expect(indexes.length).toEqual(3); + done(); + }); }); }); - }); - }) - }); + }) + }); - it('cannot delete index that does not exist', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + it('cannot delete index that does not exist', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - indexes: { - unknownIndex: { __op: 'Delete' } + body: {}, + }, () => { + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + unknownIndex: { __op: 'Delete' } + } } - } - }, (error, response, body) => { - expect(body.code).toBe(Parse.Error.INVALID_QUERY); - expect(body.error).toBe('Index unknownIndex does not exist, cannot delete.'); - done(); - }); - }) - }); + }, (error, response, body) => { + expect(body.code).toBe(Parse.Error.INVALID_QUERY); + expect(body.error).toBe('Index unknownIndex does not exist, cannot delete.'); + done(); + }); + }) + }); - it('cannot update index that exist', done => { - request.post({ - url: 'http://localhost:8378/1/schemas/NewClass', - headers: masterKeyHeaders, - json: true, - body: {}, - }, () => { - request.put({ + it('cannot update index that exist', done => { + request.post({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, - body: { - fields: { - aString: {type: 'String'}, - }, - indexes: { - name1: { aString: 1 } - } - } + body: {}, }, () => { request.put({ url: 'http://localhost:8378/1/schemas/NewClass', headers: masterKeyHeaders, json: true, body: { + fields: { + aString: {type: 'String'}, + }, indexes: { - name1: { field2: 1 } + name1: { aString: 1 } } } + }, () => { + request.put({ + url: 'http://localhost:8378/1/schemas/NewClass', + headers: masterKeyHeaders, + json: true, + body: { + indexes: { + name1: { field2: 1 } + } + } + }, (error, response, body) => { + expect(body.code).toBe(Parse.Error.INVALID_QUERY); + expect(body.error).toBe('Index name1 exists, cannot update.'); + done(); + }); + }); + }) + }); + + it_exclude_dbs(['postgres'])('get indexes on startup', (done) => { + const obj = new Parse.Object('TestObject'); + obj.save().then(() => { + return reconfigureServer({ + appId: 'test', + restAPIKey: 'test', + publicServerURL: 'http://localhost:8378/1', + }); + }).then(() => { + request.get({ + url: 'http://localhost:8378/1/schemas/TestObject', + headers: masterKeyHeaders, + json: true, }, (error, response, body) => { - expect(body.code).toBe(Parse.Error.INVALID_QUERY); - expect(body.error).toBe('Index name1 exists, cannot update.'); + expect(body.indexes._id_).toBeDefined(); done(); }); }); - }) - }); + }); - it_exclude_dbs(['postgres'])('get indexes on startup', (done) => { - const obj = new Parse.Object('TestObject'); - obj.save().then(() => { - return reconfigureServer({ - appId: 'test', - restAPIKey: 'test', - publicServerURL: 'http://localhost:8378/1', - }); - }).then(() => { - request.get({ - url: 'http://localhost:8378/1/schemas/TestObject', - headers: masterKeyHeaders, - json: true, - }, (error, response, body) => { - expect(body.indexes._id_).toBeDefined(); - done(); + it_exclude_dbs(['postgres'])('get compound indexes on startup', (done) => { + const obj = new Parse.Object('TestObject'); + obj.set('subject', 'subject'); + obj.set('comment', 'comment'); + obj.save().then(() => { + return config.database.adapter.createIndex('TestObject', {subject: 'text', comment: 'text'}); + }).then(() => { + return reconfigureServer({ + appId: 'test', + restAPIKey: 'test', + publicServerURL: 'http://localhost:8378/1', + }); + }).then(() => { + request.get({ + url: 'http://localhost:8378/1/schemas/TestObject', + headers: masterKeyHeaders, + json: true, + }, (error, response, body) => { + expect(body.indexes._id_).toBeDefined(); + expect(body.indexes._id_._id).toEqual(1); + expect(body.indexes.subject_text_comment_text).toBeDefined(); + expect(body.indexes.subject_text_comment_text.subject).toEqual('text'); + expect(body.indexes.subject_text_comment_text.comment).toEqual('text'); + done(); + }); }); }); - }); - it_exclude_dbs(['postgres'])('get compound indexes on startup', (done) => { - const obj = new Parse.Object('TestObject'); - obj.set('subject', 'subject'); - obj.set('comment', 'comment'); - obj.save().then(() => { - return config.database.adapter.createIndex('TestObject', {subject: 'text', comment: 'text'}); - }).then(() => { - return reconfigureServer({ - appId: 'test', - restAPIKey: 'test', - publicServerURL: 'http://localhost:8378/1', - }); - }).then(() => { - request.get({ - url: 'http://localhost:8378/1/schemas/TestObject', - headers: masterKeyHeaders, - json: true, - }, (error, response, body) => { - expect(body.indexes._id_).toBeDefined(); - expect(body.indexes._id_._id).toEqual(1); - expect(body.indexes.subject_text_comment_text).toBeDefined(); - expect(body.indexes.subject_text_comment_text.subject).toEqual('text'); - expect(body.indexes.subject_text_comment_text.comment).toEqual('text'); + it_exclude_dbs(['postgres'])('cannot update to duplicate value on unique index', (done) => { + const index = { + code: 1 + }; + const obj1 = new Parse.Object('UniqueIndexClass'); + obj1.set('code', 1); + const obj2 = new Parse.Object('UniqueIndexClass'); + obj2.set('code', 2); + const adapter = config.database.adapter; + adapter._adaptiveCollection('UniqueIndexClass').then(collection => { + return collection._ensureSparseUniqueIndexInBackground(index); + }).then(() => { + return obj1.save(); + }).then(() => { + return obj2.save(); + }).then(() => { + obj1.set('code', 2); + return obj1.save(); + }).then(done.fail).catch((error) => { + expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE); done(); }); }); }); - - it_exclude_dbs(['postgres'])('cannot update to duplicate value on unique index', (done) => { - const index = { - code: 1 - }; - const obj1 = new Parse.Object('UniqueIndexClass'); - obj1.set('code', 1); - const obj2 = new Parse.Object('UniqueIndexClass'); - obj2.set('code', 2); - const adapter = config.database.adapter; - adapter._adaptiveCollection('UniqueIndexClass').then(collection => { - return collection._ensureSparseUniqueIndexInBackground(index); - }).then(() => { - return obj1.save(); - }).then(() => { - return obj2.save(); - }).then(() => { - obj1.set('code', 2); - return obj1.save(); - }).then(done.fail).catch((error) => { - expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE); - done(); - }); - }); }); diff --git a/spec/support/jasmine.json b/spec/support/jasmine.json index 3f247853a2..1fff21a70f 100644 --- a/spec/support/jasmine.json +++ b/spec/support/jasmine.json @@ -4,7 +4,6 @@ "*spec.js" ], "helpers": [ - "../node_modules/babel-core/register.js", "helper.js" ], "random": false diff --git a/spec/testing-routes.js b/spec/testing-routes.js index ac982ffce8..29cb6cf5f6 100644 --- a/spec/testing-routes.js +++ b/spec/testing-routes.js @@ -1,11 +1,11 @@ // testing-routes.js -import AppCache from '../src/cache'; -import * as middlewares from '../src/middlewares'; -import { ParseServer } from '../src/index'; -import { Parse } from 'parse/node'; +const AppCache = require('../lib/cache').default; +const middlewares = require('../lib/middlewares'); +const { ParseServer } = require('../lib/index'); +const { Parse } = require('parse/node'); const express = require('express'), - cryptoUtils = require('../src/cryptoUtils'); + cryptoUtils = require('../lib/cryptoUtils'); const router = express.Router(); diff --git a/src/Adapters/Auth/facebook.js b/src/Adapters/Auth/facebook.js index ab846e43e6..b36f59017c 100644 --- a/src/Adapters/Auth/facebook.js +++ b/src/Adapters/Auth/facebook.js @@ -37,7 +37,7 @@ function validateAppId(appIds, authData) { // A promisey wrapper for FB graph requests. function graphRequest(path) { return new Promise(function(resolve, reject) { - https.get('https://graph.facebook.com/v2.5/' + path, function(res) { + https.get('https://graph.facebook.com/' + path, function(res) { var data = ''; res.on('data', function(chunk) { data += chunk; diff --git a/src/Adapters/Auth/vkontakte.js b/src/Adapters/Auth/vkontakte.js index 8c9bd5efc8..b43b60f189 100644 --- a/src/Adapters/Auth/vkontakte.js +++ b/src/Adapters/Auth/vkontakte.js @@ -10,7 +10,7 @@ var logger = require('../../logger').default; function validateAuthData(authData, params) { return vkOAuth2Request(params).then(function (response) { if (response && response.access_token) { - return request("api.vk.com", "method/secure.checkToken?token=" + authData.access_token + "&client_secret=" + params.appSecret + "&access_token=" + response.access_token).then(function (response) { + return request("api.vk.com", "method/secure.checkToken?token=" + authData.access_token + "&client_secret=" + params.appSecret + "&access_token=" + response.access_token + "&v=5.59").then(function (response) { if (response && response.response && response.response.user_id == authData.id) { return; } diff --git a/src/Adapters/Storage/Mongo/MongoStorageAdapter.js b/src/Adapters/Storage/Mongo/MongoStorageAdapter.js index e1db8b93b2..333efb314c 100644 --- a/src/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/src/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -161,7 +161,7 @@ export class MongoStorageAdapter implements StorageAdapter { return this.connectionPromise; } - handleError(error: ?Error): Promise { + handleError(error: ?(Error | Parse.Error)): Promise { if (error && error.code === 13) { // Unauthorized error delete this.client; delete this.database; @@ -313,11 +313,9 @@ export class MongoStorageAdapter implements StorageAdapter { .catch(err => this.handleError(err)); } - // Delete all data known to this adapter. Used for testing. - deleteAllClasses() { + deleteAllClasses(fast: boolean) { return storageAdapterAllCollections(this) - .then(collections => Promise.all(collections.map(collection => collection.drop()))) - .catch(err => this.handleError(err)); + .then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop()))); } // Remove the column and all the data. For Relations, the _Join collection is handled @@ -557,26 +555,17 @@ export class MongoStorageAdapter implements StorageAdapter { aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) { let isPointerField = false; pipeline = pipeline.map((stage) => { - if (stage.$group && stage.$group._id && (typeof stage.$group._id === 'string')) { - const field = stage.$group._id.substring(1); - if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + if (stage.$group) { + stage.$group = this._parseAggregateGroupArgs(schema, stage.$group); + if (stage.$group._id && (typeof stage.$group._id === 'string') && stage.$group._id.indexOf('$_p_') >= 0) { isPointerField = true; - stage.$group._id = `$_p_${field}`; } } if (stage.$match) { - for (const field in stage.$match) { - if (schema.fields[field] && schema.fields[field].type === 'Pointer') { - const transformMatch = { [`_p_${field}`] : `${className}$${stage.$match[field]}` }; - stage.$match = transformMatch; - } - if (field === 'objectId') { - const transformMatch = Object.assign({}, stage.$match); - transformMatch._id = stage.$match[field]; - delete transformMatch.objectId; - stage.$match = transformMatch; - } - } + stage.$match = this._parseAggregateArgs(schema, stage.$match); + } + if (stage.$project) { + stage.$project = this._parseAggregateProjectArgs(schema, stage.$project); } return stage; }); @@ -608,6 +597,130 @@ export class MongoStorageAdapter implements StorageAdapter { .catch(err => this.handleError(err)); } + // This function will recursively traverse the pipeline and convert any Pointer or Date columns. + // If we detect a pointer column we will rename the column being queried for to match the column + // in the database. We also modify the value to what we expect the value to be in the database + // as well. + // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert + // the string to a Date so the driver can perform the necessary comparison. + // + // The goal of this method is to look for the "leaves" of the pipeline and determine if it needs + // to be converted. The pipeline can have a few different forms. For more details, see: + // https://docs.mongodb.com/manual/reference/operator/aggregation/ + // + // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In + // that case we need to loop through all of it's children to find the columns being operated on. + // If the pipeline is an object, then we'll loop through the keys checking to see if the key name + // matches one of the schema columns. If it does match a column and the column is a Pointer or + // a Date, then we'll convert the value as described above. + // + // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing + // down a tree to find a "leaf node" and checking to see if it needs to be converted. + _parseAggregateArgs(schema: any, pipeline: any): any { + if (Array.isArray(pipeline)) { + return pipeline.map((value) => this._parseAggregateArgs(schema, value)); + } else if (typeof pipeline === 'object') { + const returnValue = {}; + for (const field in pipeline) { + if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + if (typeof pipeline[field] === 'object') { + // Pass objects down to MongoDB...this is more than likely an $exists operator. + returnValue[`_p_${field}`] = pipeline[field]; + } else { + returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`; + } + } else if (schema.fields[field] && schema.fields[field].type === 'Date') { + returnValue[field] = this._convertToDate(pipeline[field]); + } else { + returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]); + } + + if (field === 'objectId') { + returnValue['_id'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'createdAt') { + returnValue['_created_at'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'updatedAt') { + returnValue['_updated_at'] = returnValue[field]; + delete returnValue[field]; + } + } + return returnValue; + } + return pipeline; + } + + // This function is slightly different than the one above. Rather than trying to combine these + // two functions and making the code even harder to understand, I decided to split it up. The + // difference with this function is we are not transforming the values, only the keys of the + // pipeline. + _parseAggregateProjectArgs(schema: any, pipeline: any): any { + const returnValue = {}; + for (const field in pipeline) { + if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + returnValue[`_p_${field}`] = pipeline[field]; + } else { + returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]); + } + + if (field === 'objectId') { + returnValue['_id'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'createdAt') { + returnValue['_created_at'] = returnValue[field]; + delete returnValue[field]; + } else if (field === 'updatedAt') { + returnValue['_updated_at'] = returnValue[field]; + delete returnValue[field]; + } + } + return returnValue; + } + + // This function is slightly different than the two above. MongoDB $group aggregate looks like: + // { $group: { _id: , : { : }, ... } } + // The could be a column name, prefixed with the '$' character. We'll look for + // these and check to see if it is a 'Pointer' or if it's one of createdAt, + // updatedAt or objectId and change it accordingly. + _parseAggregateGroupArgs(schema: any, pipeline: any): any { + if (Array.isArray(pipeline)) { + return pipeline.map((value) => this._parseAggregateGroupArgs(schema, value)); + } else if (typeof pipeline === 'object') { + const returnValue = {}; + for (const field in pipeline) { + returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]); + } + return returnValue; + } else if (typeof pipeline === 'string') { + const field = pipeline.substring(1); + if (schema.fields[field] && schema.fields[field].type === 'Pointer') { + return `$_p_${field}`; + } else if (field == 'createdAt') { + return '$_created_at'; + } else if (field == 'updatedAt') { + return '$_updated_at'; + } + } + return pipeline; + } + + // This function will attempt to convert the provided value to a Date object. Since this is part + // of an aggregation pipeline, the value can either be a string or it can be another object with + // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a + // recursive method to traverse down to the "leaf node" which is going to be the string. + _convertToDate(value: any): any { + if (typeof value === 'string') { + return new Date(value); + } + + const returnValue = {} + for (const field in value) { + returnValue[field] = this._convertToDate(value[field]) + } + return returnValue; + } + _parseReadPreference(readPreference: ?string): ?string { switch (readPreference) { case 'PRIMARY': @@ -626,8 +739,6 @@ export class MongoStorageAdapter implements StorageAdapter { readPreference = ReadPreference.NEAREST; break; case undefined: - // this is to match existing tests, which were failing as mongodb@3.0 don't report readPreference anymore - readPreference = ReadPreference.PRIMARY; break; default: throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.'); diff --git a/src/Adapters/Storage/Mongo/MongoTransform.js b/src/Adapters/Storage/Mongo/MongoTransform.js index a5cbe1f195..453bddef70 100644 --- a/src/Adapters/Storage/Mongo/MongoTransform.js +++ b/src/Adapters/Storage/Mongo/MongoTransform.js @@ -123,6 +123,44 @@ const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSc return {key, value}; } +const isRegex = value => { + return value && (value instanceof RegExp) +} + +const isStartsWithRegex = value => { + if (!isRegex(value)) { + return false; + } + + const matches = value.toString().match(/\/\^\\Q.*\\E\//); + return !!matches; +} + +const isAllValuesRegexOrNone = values => { + if (!values || !Array.isArray(values) || values.length === 0) { + return true; + } + + const firstValuesIsRegex = isStartsWithRegex(values[0]); + if (values.length === 1) { + return firstValuesIsRegex; + } + + for (let i = 1, length = values.length; i < length; ++i) { + if (firstValuesIsRegex !== isStartsWithRegex(values[i])) { + return false; + } + } + + return true; +} + +const isAnyValueRegex = values => { + return values.some(function (value) { + return isRegex(value); + }); +} + const transformInteriorValue = restValue => { 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"); @@ -209,9 +247,9 @@ function transformQueryKeyValue(className, key, value, schema) { case '_perishable_token': case '_email_verify_token': return {key, value} case '$or': - return {key: '$or', value: value.map(subQuery => transformWhere(className, subQuery, schema))}; case '$and': - return {key: '$and', value: value.map(subQuery => transformWhere(className, subQuery, schema))}; + case '$nor': + return {key: key, value: value.map(subQuery => transformWhere(className, subQuery, schema))}; case 'lastUsed': if (valueAsDate(value)) { return {key: '_last_used', value: valueAsDate(value)} @@ -252,6 +290,9 @@ function transformQueryKeyValue(className, key, value, schema) { if (transformedConstraint.$text) { return {key: '$text', value: transformedConstraint.$text}; } + if (transformedConstraint.$elemMatch) { + return { key: '$nor', value: [{ [key]: transformedConstraint }] }; + } return {key, value: transformedConstraint}; } @@ -469,6 +510,8 @@ const transformInteriorAtom = (atom) => { return DateCoder.JSONToDatabase(atom); } else if (BytesCoder.isValidJSON(atom)) { return BytesCoder.JSONToDatabase(atom); + } else if (typeof atom === 'object' && atom && atom.$regex !== undefined) { + return new RegExp(atom.$regex); } else { return atom; } @@ -740,6 +783,13 @@ function transformConstraint(constraint, field) { 'bad ' + key + ' value'); } answer[key] = arr.map(transformInteriorAtom); + + const values = answer[key]; + if (isAnyValueRegex(values) && !isAllValuesRegexOrNone(values)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'All $all values must be of regex type or none: ' + + values); + } + break; } case '$regex': @@ -750,6 +800,19 @@ function transformConstraint(constraint, field) { answer[key] = s; break; + case '$containedBy': { + const arr = constraint[key]; + if (!(arr instanceof Array)) { + throw new Parse.Error( + Parse.Error.INVALID_JSON, + `bad $containedBy: should be an array` + ); + } + answer.$elemMatch = { + $nin: arr.map(transformer) + }; + break; + } case '$options': answer[key] = constraint[key]; break; @@ -842,29 +905,70 @@ function transformConstraint(constraint, field) { case '$geoWithin': { const polygon = constraint[key]['$polygon']; - if (!(polygon instanceof Array)) { - throw new Parse.Error( - Parse.Error.INVALID_JSON, - 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints' - ); - } - if (polygon.length < 3) { - throw new Parse.Error( - Parse.Error.INVALID_JSON, - 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints' - ); - } - const points = polygon.map((point) => { - if (!GeoPointCoder.isValidJSON(point)) { - throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value'); + const centerSphere = constraint[key]['$centerSphere']; + if (polygon !== undefined) { + let points; + if (typeof polygon === 'object' && polygon.__type === 'Polygon') { + if (!polygon.coordinates || polygon.coordinates.length < 3) { + throw new Parse.Error( + Parse.Error.INVALID_JSON, + 'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs' + ); + } + points = polygon.coordinates; + } else if (polygon instanceof Array) { + if (polygon.length < 3) { + throw new Parse.Error( + Parse.Error.INVALID_JSON, + 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints' + ); + } + points = polygon; } else { - Parse.GeoPoint._validate(point.latitude, point.longitude); + throw new Parse.Error( + Parse.Error.INVALID_JSON, + 'bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint\'s' + ); } - return [point.longitude, point.latitude]; - }); - answer[key] = { - '$polygon': points - }; + points = points.map((point) => { + if (point instanceof Array && point.length === 2) { + Parse.GeoPoint._validate(point[1], point[0]); + return point; + } + if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value'); + } else { + Parse.GeoPoint._validate(point.latitude, point.longitude); + } + return [point.longitude, point.latitude]; + }); + answer[key] = { + '$polygon': points + }; + } else if (centerSphere !== undefined) { + if (!(centerSphere instanceof Array) || centerSphere.length < 2) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance'); + } + // Get point, convert to geo point if necessary and validate + let point = centerSphere[0]; + if (point instanceof Array && point.length === 2) { + point = new Parse.GeoPoint(point[1], point[0]); + } else if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid'); + } + Parse.GeoPoint._validate(point.latitude, point.longitude); + // Get distance and validate + const distance = centerSphere[1]; + if(isNaN(distance) || distance < 0) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid'); + } + answer[key] = { + '$centerSphere': [ + [point.longitude, point.latitude], + distance + ] + }; + } break; } case '$geoIntersects': { diff --git a/src/Adapters/Storage/Postgres/PostgresStorageAdapter.js b/src/Adapters/Storage/Postgres/PostgresStorageAdapter.js index ef005c595c..2df5abb66d 100644 --- a/src/Adapters/Storage/Postgres/PostgresStorageAdapter.js +++ b/src/Adapters/Storage/Postgres/PostgresStorageAdapter.js @@ -233,7 +233,13 @@ const joinTablesForSchema = (schema) => { return list; } -const buildWhereClause = ({ schema, query, index }) => { +interface WhereClause { + pattern: string; + values: Array; + sorts: Array; +} + +const buildWhereClause = ({ schema, query, index }): WhereClause => { const patterns = []; let values = []; const sorts = []; @@ -287,13 +293,20 @@ const buildWhereClause = ({ schema, query, index }) => { index += 2; } else if (typeof fieldValue === 'boolean') { patterns.push(`$${index}:name = $${index + 1}`); - values.push(fieldName, fieldValue); + // Can't cast boolean to double precision + if (schema.fields[fieldName] && schema.fields[fieldName].type === 'Number') { + // Should always return zero results + const MAX_INT_PLUS_ONE = 9223372036854775808; + values.push(fieldName, MAX_INT_PLUS_ONE); + } else { + values.push(fieldName, fieldValue); + } index += 2; } else if (typeof fieldValue === 'number') { patterns.push(`$${index}:name = $${index + 1}`); values.push(fieldName, fieldValue); index += 2; - } else if (fieldName === '$or' || fieldName === '$and') { + } else if (['$or', '$nor', '$and'].includes(fieldName)) { const clauses = []; const clauseValues = []; fieldValue.forEach((subQuery) => { @@ -304,8 +317,11 @@ const buildWhereClause = ({ schema, query, index }) => { index += clause.values.length; } }); - const orOrAnd = fieldName === '$or' ? ' OR ' : ' AND '; - patterns.push(`(${clauses.join(orOrAnd)})`); + + const orOrAnd = fieldName === '$and' ? ' AND ' : ' OR '; + const not = fieldName === '$nor' ? ' NOT ' : ''; + + patterns.push(`${not}(${clauses.join(orOrAnd)})`); values.push(...clauseValues); } @@ -329,11 +345,16 @@ const buildWhereClause = ({ schema, query, index }) => { values.push(fieldName, fieldValue.$ne); index += 2; } - - if (fieldValue.$eq) { - patterns.push(`$${index}:name = $${index + 1}`); - values.push(fieldName, fieldValue.$eq); - index += 2; + if (fieldValue.$eq !== undefined) { + if (fieldValue.$eq === null) { + patterns.push(`$${index}:name IS NULL`); + values.push(fieldName); + index += 1; + } else { + patterns.push(`$${index}:name = $${index + 1}`); + values.push(fieldName, fieldValue.$eq); + index += 2; + } } const isInOrNin = Array.isArray(fieldValue.$in) || Array.isArray(fieldValue.$nin); if (Array.isArray(fieldValue.$in) && @@ -393,10 +414,27 @@ const buildWhereClause = ({ schema, query, index }) => { if (fieldValue.$nin) { createConstraint(_.flatMap(fieldValue.$nin, elt => elt), true); } + } else if(typeof fieldValue.$in !== 'undefined') { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $in value'); + } else if (typeof fieldValue.$nin !== 'undefined') { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $nin value'); } if (Array.isArray(fieldValue.$all) && isArrayField) { - patterns.push(`array_contains_all($${index}:name, $${index + 1}::jsonb)`); + if (isAnyValueRegexStartsWith(fieldValue.$all)) { + if (!isAllValuesRegexOrNone(fieldValue.$all)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'All $all values must be of regex type or none: ' + + fieldValue.$all); + } + + for (let i = 0; i < fieldValue.$all.length; i += 1) { + const value = processRegexPattern(fieldValue.$all[i].$regex); + fieldValue.$all[i] = value.substring(1) + '%'; + } + patterns.push(`array_contains_all_regex($${index}:name, $${index + 1}::jsonb)`); + } else { + patterns.push(`array_contains_all($${index}:name, $${index + 1}::jsonb)`); + } values.push(fieldName, JSON.stringify(fieldValue.$all)); index += 2; } @@ -411,6 +449,20 @@ const buildWhereClause = ({ schema, query, index }) => { index += 1; } + if (fieldValue.$containedBy) { + const arr = fieldValue.$containedBy; + if (!(arr instanceof Array)) { + throw new Parse.Error( + Parse.Error.INVALID_JSON, + `bad $containedBy: should be an array` + ); + } + + patterns.push(`$${index}:name <@ $${index + 1}::jsonb`); + values.push(fieldName, JSON.stringify(arr)); + index += 2; + } + if (fieldValue.$text) { const search = fieldValue.$text.$search; let language = 'english'; @@ -483,21 +535,60 @@ const buildWhereClause = ({ schema, query, index }) => { index += 2; } + if (fieldValue.$geoWithin && fieldValue.$geoWithin.$centerSphere) { + const centerSphere = fieldValue.$geoWithin.$centerSphere; + if (!(centerSphere instanceof Array) || centerSphere.length < 2) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere should be an array of Parse.GeoPoint and distance'); + } + // Get point, convert to geo point if necessary and validate + let point = centerSphere[0]; + if (point instanceof Array && point.length === 2) { + point = new Parse.GeoPoint(point[1], point[0]); + } else if (!GeoPointCoder.isValidJSON(point)) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere geo point invalid'); + } + Parse.GeoPoint._validate(point.latitude, point.longitude); + // Get distance and validate + const distance = centerSphere[1]; + if(isNaN(distance) || distance < 0) { + throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value; $centerSphere distance invalid'); + } + const distanceInKM = distance * 6371 * 1000; + patterns.push(`ST_distance_sphere($${index}:name::geometry, POINT($${index + 1}, $${index + 2})::geometry) <= $${index + 3}`); + values.push(fieldName, point.longitude, point.latitude, distanceInKM); + index += 4; + } + if (fieldValue.$geoWithin && fieldValue.$geoWithin.$polygon) { const polygon = fieldValue.$geoWithin.$polygon; - if (!(polygon instanceof Array)) { - throw new Parse.Error( - Parse.Error.INVALID_JSON, - 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints' - ); - } - if (polygon.length < 3) { + let points; + if (typeof polygon === 'object' && polygon.__type === 'Polygon') { + if (!polygon.coordinates || polygon.coordinates.length < 3) { + throw new Parse.Error( + Parse.Error.INVALID_JSON, + 'bad $geoWithin value; Polygon.coordinates should contain at least 3 lon/lat pairs' + ); + } + points = polygon.coordinates; + } else if ((polygon instanceof Array)) { + if (polygon.length < 3) { + throw new Parse.Error( + Parse.Error.INVALID_JSON, + 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints' + ); + } + points = polygon; + } else { throw new Parse.Error( Parse.Error.INVALID_JSON, - 'bad $geoWithin value; $polygon should contain at least 3 GeoPoints' + 'bad $geoWithin value; $polygon should be Polygon object or Array of Parse.GeoPoint\'s' ); } - const points = polygon.map((point) => { + points = points.map((point) => { + if (point instanceof Array && point.length === 2) { + Parse.GeoPoint._validate(point[1], point[0]); + return `(${point[0]}, ${point[1]})`; + } if (typeof point !== 'object' || point.__type !== 'GeoPoint') { throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad $geoWithin value'); } else { @@ -578,7 +669,7 @@ const buildWhereClause = ({ schema, query, index }) => { } Object.keys(ParseToPosgresComparator).forEach(cmp => { - if (fieldValue[cmp]) { + if (fieldValue[cmp] || fieldValue[cmp] === 0) { const pgComparator = ParseToPosgresComparator[cmp]; patterns.push(`$${index}:name ${pgComparator} $${index + 1}`); values.push(fieldName, toPostgresValue(fieldValue[cmp])); @@ -595,6 +686,9 @@ const buildWhereClause = ({ schema, query, index }) => { } export class PostgresStorageAdapter implements StorageAdapter { + + canSortOnJoinTables: boolean; + // Private _collectionPrefix: string; _client: any; @@ -609,6 +703,7 @@ export class PostgresStorageAdapter implements StorageAdapter { const { client, pgp } = createClient(uri, databaseOptions); this._client = client; this._pgp = pgp; + this.canSortOnJoinTables = false; } handleShutdown() { @@ -846,7 +941,7 @@ export class PostgresStorageAdapter implements StorageAdapter { return this._client.task('delete-all-classes', function * (t) { try { const results = yield t.any('SELECT * FROM "_SCHEMA"'); - const joins = results.reduce((list, schema) => { + const joins = results.reduce((list: Array, schema: any) => { return list.concat(joinTablesForSchema(schema.schema)); }, []); const classes = ['_SCHEMA', '_PushStatus', '_JobStatus', '_JobSchedule', '_Hooks', '_GlobalConfig', '_Audience', ...results.map(result => result.className), ...joins]; @@ -879,7 +974,7 @@ export class PostgresStorageAdapter implements StorageAdapter { // Returns a Promise. deleteFields(className: string, schema: SchemaType, fieldNames: string[]): Promise { debug('deleteFields', className, fieldNames); - fieldNames = fieldNames.reduce((list, fieldName) => { + fieldNames = fieldNames.reduce((list: Array, fieldName: string) => { const field = schema.fields[fieldName] if (field.type !== 'Relation') { list.push(fieldName); @@ -1133,14 +1228,14 @@ export class PostgresStorageAdapter implements StorageAdapter { } else if (fieldName == 'authData') { // This recursively sets the json_object // Only 1 level deep - const generate = (jsonb, key, value) => { + const generate = (jsonb: string, key: string, value: any) => { return `json_object_set_key(COALESCE(${jsonb}, '{}'::jsonb), ${key}, ${value})::jsonb`; } const lastKey = `$${index}:name`; const fieldNameIndex = index; index += 1; values.push(fieldName); - const update = Object.keys(fieldValue).reduce((lastKey, key) => { + const update = Object.keys(fieldValue).reduce((lastKey: string, key: string) => { const str = generate(lastKey, `$${index}::text`, `$${index + 1}::jsonb`) index += 2; let value = fieldValue[key]; @@ -1243,17 +1338,17 @@ export class PostgresStorageAdapter implements StorageAdapter { }); } - const keysToDelete = Object.keys(originalUpdate).filter(k => { + const keysToDelete: Array = Object.keys(originalUpdate).filter(k => { // choose top level fields that have a delete operation set. const value = originalUpdate[k]; return value && value.__op === 'Delete' && k.split('.').length === 2 && k.split(".")[0] === fieldName; }).map(k => k.split('.')[1]); - const deletePatterns = keysToDelete.reduce((p, c, i) => { + const deletePatterns = keysToDelete.reduce((p: string, c: string, i: number) => { return p + ` - '$${index + 1 + i}:value'`; }, ''); - updatePatterns.push(`$${index}:name = ( COALESCE($${index}:name, '{}'::jsonb) ${deletePatterns} ${incrementPatterns} || $${index + 1 + keysToDelete.length}::jsonb )`); + updatePatterns.push(`$${index}:name = ('{}'::jsonb ${deletePatterns} ${incrementPatterns} || $${index + 1 + keysToDelete.length}::jsonb )`); values.push(fieldName, ...keysToDelete, JSON.stringify(fieldValue)); index += 2 + keysToDelete.length; @@ -1326,11 +1421,12 @@ export class PostgresStorageAdapter implements StorageAdapter { if (sort) { const sortCopy: any = sort; const sorting = Object.keys(sort).map((key) => { + const transformKey = transformDotFieldToComponents(key).join('->'); // Using $idx pattern gives: non-integer constant in ORDER BY if (sortCopy[key] === 1) { - return `"${key}" ASC`; + return `${transformKey} ASC`; } - return `"${key}" DESC`; + return `${transformKey} DESC`; }).join(); sortPattern = sort !== undefined && Object.keys(sort).length > 0 ? `ORDER BY ${sorting}` : ''; } @@ -1540,7 +1636,7 @@ export class PostgresStorageAdapter implements StorageAdapter { aggregate(className: string, schema: any, pipeline: any) { debug('aggregate', className, pipeline); const values = [className]; - let index = 2; + let index: number = 2; let columns: string[] = []; let countField = null; let groupValues = null; @@ -1732,6 +1828,7 @@ export class PostgresStorageAdapter implements StorageAdapter { t.none(sql.array.addUnique), t.none(sql.array.remove), t.none(sql.array.containsAll), + t.none(sql.array.containsAllRegex), t.none(sql.array.contains) ]); }); @@ -1836,6 +1933,40 @@ function processRegexPattern(s) { return literalizeRegexPart(s); } +function isStartsWithRegex(value) { + if (!value || typeof value !== 'string' || !value.startsWith('^')) { + return false; + } + + const matches = value.match(/\^\\Q.*\\E/); + return !!matches; +} + +function isAllValuesRegexOrNone(values) { + if (!values || !Array.isArray(values) || values.length === 0) { + return true; + } + + const firstValuesIsRegex = isStartsWithRegex(values[0].$regex); + if (values.length === 1) { + return firstValuesIsRegex; + } + + for (let i = 1, length = values.length; i < length; ++i) { + if (firstValuesIsRegex !== isStartsWithRegex(values[i].$regex)) { + return false; + } + } + + return true; +} + +function isAnyValueRegexStartsWith(values) { + return values.some(function (value) { + return isStartsWithRegex(value.$regex); + }); +} + function createLiteralRegex(remaining) { return remaining.split('').map(c => { if (c.match(/[0-9a-zA-Z]/) !== null) { @@ -1879,4 +2010,13 @@ function literalizeRegexPart(s: string) { ); } +var GeoPointCoder = { + isValidJSON(value) { + return (typeof value === 'object' && + value !== null && + value.__type === 'GeoPoint' + ); + } +}; + export default PostgresStorageAdapter; diff --git a/src/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql b/src/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql new file mode 100644 index 0000000000..7ca5853a9f --- /dev/null +++ b/src/Adapters/Storage/Postgres/sql/array/contains-all-regex.sql @@ -0,0 +1,14 @@ +CREATE OR REPLACE FUNCTION array_contains_all_regex( + "array" jsonb, + "values" jsonb +) + RETURNS boolean + LANGUAGE sql + IMMUTABLE + STRICT +AS $function$ + SELECT CASE + WHEN 0 = jsonb_array_length("values") THEN true = false + ELSE (SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements_text("array") as elt WHERE elt LIKE ANY (SELECT jsonb_array_elements_text("values"))) as RES) + END; +$function$; \ No newline at end of file diff --git a/src/Adapters/Storage/Postgres/sql/array/contains-all.sql b/src/Adapters/Storage/Postgres/sql/array/contains-all.sql index 24355bc732..8db1ca0e7b 100644 --- a/src/Adapters/Storage/Postgres/sql/array/contains-all.sql +++ b/src/Adapters/Storage/Postgres/sql/array/contains-all.sql @@ -7,5 +7,8 @@ CREATE OR REPLACE FUNCTION array_contains_all( IMMUTABLE STRICT AS $function$ - SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements("array") as elt WHERE elt IN (SELECT jsonb_array_elements("values"))) as RES; + SELECT CASE + WHEN 0 = jsonb_array_length("values") THEN true = false + ELSE (SELECT RES.CNT = jsonb_array_length("values") FROM (SELECT COUNT(*) as CNT FROM jsonb_array_elements_text("array") as elt WHERE elt IN (SELECT jsonb_array_elements_text("values"))) as RES) + END; $function$; diff --git a/src/Adapters/Storage/Postgres/sql/index.js b/src/Adapters/Storage/Postgres/sql/index.js index 5ddfb036cf..6bcd560d13 100644 --- a/src/Adapters/Storage/Postgres/sql/index.js +++ b/src/Adapters/Storage/Postgres/sql/index.js @@ -9,6 +9,7 @@ module.exports = { addUnique: sql('array/add-unique.sql'), contains: sql('array/contains.sql'), containsAll: sql('array/contains-all.sql'), + containsAllRegex: sql('array/contains-all-regex.sql'), remove: sql('array/remove.sql') }, misc: { diff --git a/src/Adapters/Storage/StorageAdapter.js b/src/Adapters/Storage/StorageAdapter.js index 4123117d8e..ed2c2e0701 100644 --- a/src/Adapters/Storage/StorageAdapter.js +++ b/src/Adapters/Storage/StorageAdapter.js @@ -24,12 +24,14 @@ export type UpdateQueryOptions = { export type FullQueryOptions = QueryOptions & UpdateQueryOptions; export interface StorageAdapter { + canSortOnJoinTables: boolean; + classExists(className: string): Promise; setClassLevelPermissions(className: string, clps: any): Promise; createClass(className: string, schema: SchemaType): Promise; addFieldIfNotExists(className: string, fieldName: string, type: any): Promise; deleteClass(className: string): Promise; - deleteAllClasses(): Promise; + deleteAllClasses(fast: boolean): Promise; deleteFields(className: string, schema: SchemaType, fieldNames: Array): Promise; getAllClasses(): Promise; getClass(className: string): Promise; diff --git a/src/Auth.js b/src/Auth.js index 1cb2e96563..8658f13025 100644 --- a/src/Auth.js +++ b/src/Auth.js @@ -21,14 +21,14 @@ function Auth({ config, isMaster = false, isReadOnly = false, user, installation // Whether this auth could possibly modify the given user id. // It still could be forbidden via ACLs even if this returns true. -Auth.prototype.couldUpdateUserId = function(userId) { +Auth.prototype.isUnauthenticated = function() { if (this.isMaster) { - return true; + return false; } - if (this.user && this.user.id === userId) { - return true; + if (this.user) { + return false; } - return false; + return true; }; // A helper to get a master-level Auth object @@ -64,7 +64,7 @@ var getAuthForSessionToken = function({ config, sessionToken, installationId } = return query.execute().then((response) => { var results = response.results; if (results.length !== 1 || !results[0]['user']) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } var now = new Date(), diff --git a/src/Controllers/DatabaseController.js b/src/Controllers/DatabaseController.js index 786e69ac05..372be94f81 100644 --- a/src/Controllers/DatabaseController.js +++ b/src/Controllers/DatabaseController.js @@ -50,7 +50,7 @@ const transformObjectACL = ({ ACL, ...result }) => { return 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 specialQuerykeys = ['$and', '$or', '$nor', '_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; @@ -111,6 +111,14 @@ const validateQuery = (query: any): void => { } } + if (query.$nor) { + if (query.$nor instanceof Array && query.$nor.length > 0) { + query.$nor.forEach(validateQuery); + } else { + throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Bad $nor format - use an array of at least 1 value.'); + } + } + Object.keys(query).forEach(key => { if (query && query[key] && query[key].$regex) { if (typeof query[key].$options === 'string') { @@ -147,6 +155,7 @@ const filterSensitiveData = (isMaster, aclGroup, className, object) => { delete object._failed_login_count; delete object._account_lockout_expires_at; delete object._password_changed_at; + delete object._password_history; if ((aclGroup.indexOf(object.objectId) > -1)) { return object; @@ -285,6 +294,16 @@ const untransformObjectACL = ({_rperm, _wperm, ...output}) => { return output; } +/** + * When querying, the fieldName may be compound, extract the root fieldName + * `temperature.celsius` becomes `temperature` + * @param {string} fieldName that may be a compound field name + * @returns {string} the root name of the field + */ +const getRootFieldName = (fieldName: string): string => { + return fieldName.split('.')[0] +} + const relationSchema = { fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } } }; class DatabaseController { @@ -402,13 +421,13 @@ class DatabaseController { if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`); } - fieldName = fieldName.split('.')[0]; - if (!SchemaController.fieldNameIsValid(fieldName) && !isSpecialUpdateKey(fieldName)) { + const rootFieldName = getRootFieldName(fieldName); + if (!SchemaController.fieldNameIsValid(rootFieldName) && !isSpecialUpdateKey(rootFieldName)) { throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name for update: ${fieldName}`); } }); - for (const updateOperation: any in update) { - if (Object.keys(updateOperation).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) { + for (const updateOperation in update) { + if (update[updateOperation] && typeof update[updateOperation] === 'object' && Object.keys(update[updateOperation]).some(innerKey => innerKey.includes('$') || innerKey.includes('.'))) { throw new Parse.Error(Parse.Error.INVALID_NESTED_KEY, "Nested keys should not contain the '$' or '.' characters"); } } @@ -635,11 +654,16 @@ class DatabaseController { } // Won't delete collections in the system namespace - // Returns a promise. - deleteEverything() { + /** + * Delete all classes and clears the schema cache + * + * @param {boolean} fast set to true if it's ok to just delete rows and not indexes + * @returns {Promise} when the deletions completes + */ + deleteEverything(fast: boolean = false): Promise { this.schemaPromise = null; return Promise.all([ - this.adapter.deleteAllClasses(), + this.adapter.deleteAllClasses(fast), this.schemaCache.clear() ]); } @@ -850,7 +874,8 @@ class DatabaseController { op, distinct, pipeline, - readPreference + readPreference, + isWrite, }: any = {}): Promise { const isMaster = acl === undefined; const aclGroup = acl || []; @@ -891,7 +916,8 @@ class DatabaseController { if (fieldName.match(/^authData\.([a-zA-Z0-9_]+)\.id$/)) { throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Cannot sort by ${fieldName}`); } - if (!SchemaController.fieldNameIsValid(fieldName)) { + const rootFieldName = getRootFieldName(fieldName); + if (!SchemaController.fieldNameIsValid(rootFieldName)) { throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Invalid field name: ${fieldName}.`); } }); @@ -910,7 +936,11 @@ class DatabaseController { } } if (!isMaster) { - query = addReadACL(query, aclGroup); + if (isWrite) { + query = addWriteACL(query, aclGroup); + } else { + query = addReadACL(query, aclGroup); + } } validateQuery(query); if (count) { diff --git a/src/Controllers/FilesController.js b/src/Controllers/FilesController.js index 2ea83412db..16cd2ac79c 100644 --- a/src/Controllers/FilesController.js +++ b/src/Controllers/FilesController.js @@ -2,7 +2,7 @@ import { randomHexString } from '../cryptoUtils'; import AdaptableController from './AdaptableController'; import { FilesAdapter } from '../Adapters/Files/FilesAdapter'; -import path from 'path'; +import path from 'path'; import mime from 'mime'; const legacyFilesRegex = new RegExp("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}-.*"); @@ -25,9 +25,11 @@ export class FilesController extends AdaptableController { contentType = mime.getType(filename); } - filename = randomHexString(32) + '_' + filename; + if (!this.options.preserveFileName) { + filename = randomHexString(32) + '_' + filename; + } - var location = this.adapter.getFileLocation(config, filename); + const location = this.adapter.getFileLocation(config, filename); return this.adapter.createFile(filename, data, contentType).then(() => { return Promise.resolve({ url: location, diff --git a/src/Controllers/HooksController.js b/src/Controllers/HooksController.js index 70598bb125..db87c57153 100644 --- a/src/Controllers/HooksController.js +++ b/src/Controllers/HooksController.js @@ -6,8 +6,14 @@ import * as Parse from "parse/node"; // @flow-disable-next import * as request from "request"; import { logger } from '../logger'; +import http from 'http'; +import https from 'https'; const DefaultHooksCollectionName = "_Hooks"; +const HTTPAgents = { + http: new http.Agent({ keepAlive: true }), + https: new https.Agent({ keepAlive: true }), +} export class HooksController { _applicationId:string; @@ -177,9 +183,12 @@ function wrapToHTTPRequest(hook, key) { headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(jsonBody) + body: JSON.stringify(jsonBody), }; + const agent = hook.url.startsWith('https') ? HTTPAgents['https'] : HTTPAgents['http']; + jsonRequest.agent = agent; + if (key) { jsonRequest.headers['X-Parse-Webhook-Key'] = key; } else { diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index 416b0ea4ff..8b645a3680 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -44,10 +44,13 @@ export class PushController { let restUpdate = {}; if (typeof badge == 'string' && badge.toLowerCase() === 'increment') { restUpdate = { badge: { __op: 'Increment', amount: 1 } } + } else if (typeof badge == 'object' && typeof badge.__op == 'string' && + badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) { + restUpdate = { badge: { __op: 'Increment', amount: badge.amount } } } else if (Number(badge)) { restUpdate = { badge: badge } } else { - throw "Invalid value for badge, expected number or 'Increment'"; + throw "Invalid value for badge, expected number or 'Increment' or {increment: number}"; } // Force filtering on only valid device tokens diff --git a/src/Controllers/SchemaController.js b/src/Controllers/SchemaController.js index 45d1cf9c27..cff25e043b 100644 --- a/src/Controllers/SchemaController.js +++ b/src/Controllers/SchemaController.js @@ -536,6 +536,8 @@ export default class SchemaController { delete existingFields._rperm; delete existingFields._wperm; const newSchema = buildMergedSchemaObject(existingFields, submittedFields); + const defaultFields = defaultColumns[className] || defaultColumns._Default; + const fullNewSchema = Object.assign({}, newSchema, defaultFields); const validationError = this.validateSchemaData(className, newSchema, classLevelPermissions, Object.keys(existingFields)); if (validationError) { throw new Parse.Error(validationError.code, validationError.error); @@ -567,7 +569,7 @@ export default class SchemaController { return Promise.all(promises); }) .then(() => this.setPermissions(className, classLevelPermissions, newSchema)) - .then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, newSchema)) + .then(() => this._dbAdapter.setIndexesWithSchemaFormat(className, indexes, schema.indexes, fullNewSchema)) .then(() => this.reloadData({ clearCache: true })) //TODO: Move this logic into the database adapter .then(() => { diff --git a/src/Controllers/index.js b/src/Controllers/index.js index 7f0288a481..a1958cc983 100644 --- a/src/Controllers/index.js +++ b/src/Controllers/index.js @@ -82,6 +82,7 @@ export function getFilesController(options: ParseServerOptions): FilesController databaseURI, filesAdapter, databaseAdapter, + preserveFileName, } = options; if (!filesAdapter && databaseAdapter) { throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.'; @@ -89,7 +90,7 @@ export function getFilesController(options: ParseServerOptions): FilesController const filesControllerAdapter = loadAdapter(filesAdapter, () => { return new GridStoreAdapter(databaseURI); }); - return new FilesController(filesControllerAdapter, appId); + return new FilesController(filesControllerAdapter, appId, { preserveFileName }); } export function getUserController(options: ParseServerOptions): UserController { @@ -149,7 +150,7 @@ export function getDatabaseController(options: ParseServerOptions, cacheControll export function getHooksController(options: ParseServerOptions, databaseController: DatabaseController): HooksController { const { appId, - webhookKey + webhookKey, } = options; return new HooksController(appId, databaseController, webhookKey); } @@ -228,4 +229,3 @@ export function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOption }); } } - diff --git a/src/Options/Definitions.js b/src/Options/Definitions.js index 8a58da95dc..dec6284841 100644 --- a/src/Options/Definitions.js +++ b/src/Options/Definitions.js @@ -135,6 +135,12 @@ module.exports.ParseServerOptions = { "env": "PARSE_SERVER_FILE_KEY", "help": "Key for your files" }, + "preserveFileName": { + "env": "PARSE_SERVER_PRESERVE_FILE_NAME", + "help": "Enable (or disable) the addition of a unique hash to the file names", + "action": parsers.booleanParser, + "default": false + }, "userSensitiveFields": { "env": "PARSE_SERVER_USER_SENSITIVE_FIELDS", "help": "Personally identifiable information fields in the user table the should be removed for non-authorized users.", @@ -262,6 +268,12 @@ module.exports.ParseServerOptions = { "action": parsers.booleanParser, "default": false }, + "enableExpressErrorHandler": { + "env": "PARSE_SERVER_ENABLE_EXPRESS_ERROR_HANDLER", + "help": "Enables the default express error handler for all errors", + "action": parsers.booleanParser, + "default": false + }, "objectIdSize": { "env": "PARSE_SERVER_OBJECT_ID_SIZE", "help": "Sets the number of characters in generated object id's, default 10", diff --git a/src/Options/index.js b/src/Options/index.js index e4f6c24dfb..07f0c06ba1 100644 --- a/src/Options/index.js +++ b/src/Options/index.js @@ -64,6 +64,9 @@ export interface ParseServerOptions { webhookKey: ?string; /* Key for your files */ fileKey: ?string; + /* Enable (or disable) the addition of a unique hash to the file names + :ENV: PARSE_SERVER_PRESERVE_FILE_NAME */ + preserveFileName: ?boolean; // = false /* Personally identifiable information fields in the user table the should be removed for non-authorized users. */ userSensitiveFields: ?string[]; // = ["email"] /* Enable (or disable) anon users, defaults to true @@ -114,6 +117,8 @@ export interface ParseServerOptions { cacheMaxSize : ?number; // = 10000 /* Use a single schema cache shared across requests. Reduces number of queries made to _SCHEMA. Defaults to false, i.e. unique schema cache per request. */ enableSingleSchemaCache: ?boolean; // = false + /* Enables the default express error handler for all errors */ + enableExpressErrorHandler: ?boolean; // = false /* Sets the number of characters in generated object id's, default 10 */ objectIdSize: ?number; // = 10 /* The port to run the ParseServer. defaults to 1337. diff --git a/src/Push/PushWorker.js b/src/Push/PushWorker.js index 2f05194176..9b16baac7f 100644 --- a/src/Push/PushWorker.js +++ b/src/Push/PushWorker.js @@ -42,13 +42,7 @@ export class PushWorker { } } - unsubscribe(): void { - if (this.subscriber) { - this.subscriber.unsubscribe(this.channel); - } - } - - run({ body, query, pushStatus, applicationId, UTCOffset }: any): Promise { + run({ body, query, pushStatus, applicationId, UTCOffset }: any): Promise { const config = Config.get(applicationId); const auth = master(config); const where = utils.applyDeviceTokenExists(query.where); @@ -59,12 +53,10 @@ export class PushWorker { return pushStatus.trackSent(results); } return this.sendToAdapter(body, results, pushStatus, config, UTCOffset); - }, err => { - throw err; }); } - sendToAdapter(body: any, installations: any, pushStatus: any, config: Config, UTCOffset: any): Promise { + sendToAdapter(body: any, installations: any, pushStatus: any, config: Config, UTCOffset: any): Promise { // Check if we have locales in the push body const locales = utils.getLocalesFromPush(body); if (locales.length > 0) { @@ -102,7 +94,7 @@ export class PushWorker { return Promise.all(promises); } - getAndRun(workItem: any): Promise { + getAndRun(workItem: any): Promise { var _this = this; if (!_this.subscriber.run) { return _this.run(workItem); diff --git a/src/Push/utils.js b/src/Push/utils.js index ed33a66a14..f9b1a4118f 100644 --- a/src/Push/utils.js +++ b/src/Push/utils.js @@ -2,10 +2,17 @@ import Parse from 'parse/node'; import deepcopy from 'deepcopy'; export function isPushIncrementing(body) { - return body.data && - body.data.badge && - typeof body.data.badge == 'string' && - body.data.badge.toLowerCase() == "increment" + if (!body.data || !body.data.badge) { + return false; + } + + const badge = body.data.badge; + if (typeof badge == 'string' && badge.toLowerCase() == "increment") { + return true; + } + + return typeof badge == 'object' && typeof badge.__op == 'string' && + badge.__op.toLowerCase() == "increment" && Number(badge.amount); } const localizableKeys = ['alert', 'title']; diff --git a/src/RestQuery.js b/src/RestQuery.js index 6899b13f21..db21043bcc 100644 --- a/src/RestQuery.js +++ b/src/RestQuery.js @@ -24,12 +24,13 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl this.clientSDK = clientSDK; this.response = null; this.findOptions = {}; + this.isWrite = false; + if (!this.auth.isMaster) { - this.findOptions.acl = this.auth.user ? [this.auth.user.id] : null; if (this.className == '_Session') { - if (!this.findOptions.acl) { + if (!this.auth.user) { throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, - 'This session token is invalid.'); + 'Invalid session token'); } this.restWhere = { '$and': [this.restWhere, { @@ -44,6 +45,7 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl } this.doCount = false; + this.includeAll = false; // The format for this.include is not the same as the format for the // include option - it's the paths we should include, in order, @@ -86,6 +88,9 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl case 'count': this.doCount = true; break; + case 'includeAll': + this.includeAll = true; + break; case 'distinct': case 'pipeline': case 'skip': @@ -149,6 +154,8 @@ function RestQuery(config, auth, className, restWhere = {}, restOptions = {}, cl RestQuery.prototype.execute = function(executeOptions) { return Promise.resolve().then(() => { return this.buildRestWhere(); + }).then(() => { + return this.handleIncludeAll(); }).then(() => { return this.runFind(executeOptions); }).then(() => { @@ -182,17 +189,28 @@ RestQuery.prototype.buildRestWhere = function() { }); } +// Marks the query for a write attempt, so we read the proper ACL (write instead of read) +RestQuery.prototype.forWrite = function() { + this.isWrite = true; + return this; +} + // Uses the Auth object to get the list of roles, adds the user id RestQuery.prototype.getUserAndRoleACL = function() { - if (this.auth.isMaster || !this.auth.user) { + if (this.auth.isMaster) { return Promise.resolve(); } - return this.auth.getUserRoles().then((roles) => { - // Concat with the roles to prevent duplications on multiple calls - const aclSet = new Set([].concat(this.findOptions.acl, roles)); - this.findOptions.acl = Array.from(aclSet); + + this.findOptions.acl = ['*']; + + if (this.auth.user) { + return this.auth.getUserRoles().then((roles) => { + this.findOptions.acl = this.findOptions.acl.concat(roles, [this.auth.user.id]); + return; + }); + } else { return Promise.resolve(); - }); + } }; // Changes the className if redirectClassNameForKey is set. @@ -521,6 +539,9 @@ RestQuery.prototype.runFind = function(options = {}) { if (options.op) { findOptions.op = options.op; } + if (this.isWrite) { + findOptions.isWrite = true; + } return this.config.database.find(this.className, this.restWhere, findOptions) .then((results) => { if (this.className === '_User') { @@ -556,6 +577,31 @@ RestQuery.prototype.runCount = function() { }); }; +// Augments this.response with all pointers on an object +RestQuery.prototype.handleIncludeAll = function() { + if (!this.includeAll) { + return; + } + return this.config.database.loadSchema() + .then(schemaController => schemaController.getOneSchema(this.className)) + .then(schema => { + const includeFields = []; + const keyFields = []; + for (const field in schema.fields) { + if (schema.fields[field].type && schema.fields[field].type === 'Pointer') { + includeFields.push([field]); + keyFields.push(field); + } + } + // Add fields to include, keys, remove dups + this.include = [...new Set([...this.include, ...includeFields])]; + // if this.keys not set, then all keys are already included + if (this.keys) { + this.keys = [...new Set([...this.keys, ...keyFields])]; + } + }); +}; + // Augments this.response with data at the paths provided in this.include. RestQuery.prototype.handleInclude = function() { if (this.include.length == 0) { @@ -594,7 +640,18 @@ RestQuery.prototype.runAfterFindTrigger = function() { } // Run afterFind trigger and set the new results return triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, this.auth, this.className,this.response.results, this.config).then((results) => { - this.response.results = results; + // Ensure we properly set the className back + if (this.redirectClassName) { + this.response.results = results.map((object) => { + if (object instanceof Parse.Object) { + object = object.toJSON(); + } + object.className = this.redirectClassName; + return object; + }); + } else { + this.response.results = results; + } }); }; diff --git a/src/RestWrite.js b/src/RestWrite.js index 82f21edf3e..2a8bb2df0e 100644 --- a/src/RestWrite.js +++ b/src/RestWrite.js @@ -279,11 +279,23 @@ RestWrite.prototype.findUsersWithAuthData = function(authData) { return findPromise; } +RestWrite.prototype.filteredObjectsByACL = function(objects) { + if (this.auth.isMaster) { + return objects; + } + return objects.filter((object) => { + if (!object.ACL) { + return true; // legacy users that have no ACL field on them + } + // Regular users that have been locked out. + return object.ACL && Object.keys(object.ACL).length > 0; + }); +} RestWrite.prototype.handleAuthData = function(authData) { let results; return this.findUsersWithAuthData(authData).then((r) => { - results = r; + results = this.filteredObjectsByACL(r); if (results.length > 1) { // More than 1 user with the passed id's throw new Parse.Error(Parse.Error.ACCOUNT_ALREADY_LINKED, @@ -964,7 +976,7 @@ RestWrite.prototype.runDatabaseOperation = function() { if (this.className === '_User' && this.query && - !this.auth.couldUpdateUserId(this.query.objectId)) { + this.auth.isUnauthenticated()) { throw new Parse.Error(Parse.Error.SESSION_MISSING, `Cannot modify user ${this.query.objectId}.`); } @@ -981,7 +993,7 @@ RestWrite.prototype.runDatabaseOperation = function() { if (this.query) { // Force the user to not lockout // Matched with parse.com - if (this.className === '_User' && this.data.ACL) { + if (this.className === '_User' && this.data.ACL && this.auth.isMaster !== true) { this.data.ACL[this.query.objectId] = { read: true, write: true }; } // update password timestamp if user password is being changed diff --git a/src/Routers/AggregateRouter.js b/src/Routers/AggregateRouter.js index 8f4e859b6d..c99436f380 100644 --- a/src/Routers/AggregateRouter.js +++ b/src/Routers/AggregateRouter.js @@ -4,60 +4,56 @@ import * as middleware from '../middlewares'; import Parse from 'parse/node'; import UsersRouter from './UsersRouter'; -const ALLOWED_KEYS = [ - 'where', - 'distinct', - 'project', +const BASE_KEYS = ['where', 'distinct']; + +const PIPELINE_KEYS = [ + 'addFields', + 'bucket', + 'bucketAuto', + 'collStats', + 'count', + 'currentOp', + 'facet', + 'geoNear', + 'graphLookup', + 'group', + 'indexStats', + 'limit', + 'listLocalSessions', + 'listSessions', + 'lookup', 'match', + 'out', + 'project', 'redact', - 'limit', - 'skip', - 'unwind', - 'group', + 'replaceRoot', 'sample', + 'skip', 'sort', - 'geoNear', - 'lookup', - 'out', - 'indexStats', - 'facet', - 'bucket', - 'bucketAuto', 'sortByCount', - 'addFields', - 'replaceRoot', - 'count', - 'graphLookup', + 'unwind', ]; +const ALLOWED_KEYS = [...BASE_KEYS, ...PIPELINE_KEYS]; + export class AggregateRouter extends ClassesRouter { handleFind(req) { const body = Object.assign(req.body, ClassesRouter.JSONFromQuery(req.query)); const options = {}; - const pipeline = []; + let pipeline = []; - for (const key in body) { - if (ALLOWED_KEYS.indexOf(key) === -1) { - throw new Parse.Error(Parse.Error.INVALID_QUERY, `Invalid parameter for query: ${key}`); + if (Array.isArray(body)) { + pipeline = body.map((stage) => { + const stageName = Object.keys(stage)[0]; + return this.transformStage(stageName, stage); + }); + } else { + const stages = []; + for (const stageName in body) { + stages.push(this.transformStage(stageName, body)); } - if (key === 'group') { - if (body[key].hasOwnProperty('_id')) { - throw new Parse.Error( - Parse.Error.INVALID_QUERY, - `Invalid parameter for query: group. Please use objectId instead of _id` - ); - } - if (!body[key].hasOwnProperty('objectId')) { - throw new Parse.Error( - Parse.Error.INVALID_QUERY, - `Invalid parameter for query: group. objectId is required` - ); - } - body[key]._id = body[key].objectId; - delete body[key].objectId; - } - pipeline.push({ [`$${key}`]: body[key] }); + pipeline = stages; } if (body.distinct) { options.distinct = String(body.distinct); @@ -76,6 +72,32 @@ export class AggregateRouter extends ClassesRouter { }); } + transformStage(stageName, stage) { + if (ALLOWED_KEYS.indexOf(stageName) === -1) { + throw new Parse.Error( + Parse.Error.INVALID_QUERY, + `Invalid parameter for query: ${stageName}` + ); + } + if (stageName === 'group') { + if (stage[stageName].hasOwnProperty('_id')) { + throw new Parse.Error( + Parse.Error.INVALID_QUERY, + `Invalid parameter for query: group. Please use objectId instead of _id` + ); + } + if (!stage[stageName].hasOwnProperty('objectId')) { + throw new Parse.Error( + Parse.Error.INVALID_QUERY, + `Invalid parameter for query: group. objectId is required` + ); + } + stage[stageName]._id = stage[stageName].objectId; + delete stage[stageName].objectId; + } + return { [`$${stageName}`]: stage[stageName] }; + } + mountRoutes() { this.route('GET','/aggregate/:className', middleware.promiseEnforceMasterKeyAccess, req => { return this.handleFind(req); }); } diff --git a/src/Routers/ClassesRouter.js b/src/Routers/ClassesRouter.js index a9cb49333f..e7205015b8 100644 --- a/src/Routers/ClassesRouter.js +++ b/src/Routers/ClassesRouter.js @@ -100,7 +100,7 @@ export class ClassesRouter extends PromiseRouter { static optionsFromBody(body) { const allowConstraints = ['skip', 'limit', 'order', 'count', 'keys', - 'include', 'redirectClassNameForKey', 'where']; + 'include', 'includeAll', 'redirectClassNameForKey', 'where']; for (const key of Object.keys(body)) { if (allowConstraints.indexOf(key) === -1) { @@ -128,6 +128,9 @@ export class ClassesRouter extends PromiseRouter { if (body.include) { options.include = String(body.include); } + if (body.includeAll) { + options.includeAll = true; + } return options; } diff --git a/src/Routers/FunctionsRouter.js b/src/Routers/FunctionsRouter.js index f3ea4d3872..1bb077acd7 100644 --- a/src/Routers/FunctionsRouter.js +++ b/src/Routers/FunctionsRouter.js @@ -89,6 +89,9 @@ export class FunctionsRouter extends PromiseRouter { }, error: function(code, message) { if (!message) { + if (code instanceof Parse.Error) { + return reject(code) + } message = code; code = Parse.Error.SCRIPT_FAILED; } diff --git a/src/Routers/PurgeRouter.js b/src/Routers/PurgeRouter.js index 8c2a340da9..b9009453c6 100644 --- a/src/Routers/PurgeRouter.js +++ b/src/Routers/PurgeRouter.js @@ -1,5 +1,6 @@ import PromiseRouter from '../PromiseRouter'; import * as middleware from '../middlewares'; +import Parse from 'parse/node'; export class PurgeRouter extends PromiseRouter { @@ -16,6 +17,11 @@ export class PurgeRouter extends PromiseRouter { cacheAdapter.role.clear(); } return {response: {}}; + }).catch((error) => { + if (!error || (error && error.code === Parse.Error.OBJECT_NOT_FOUND)) { + return {response: {}}; + } + throw error; }); } diff --git a/src/Routers/UsersRouter.js b/src/Routers/UsersRouter.js index c18be9ae79..3c8690ea50 100644 --- a/src/Routers/UsersRouter.js +++ b/src/Routers/UsersRouter.js @@ -1,11 +1,11 @@ // These methods handle the User-related routes. -import Parse from 'parse/node'; -import Config from '../Config'; +import Parse from 'parse/node'; +import Config from '../Config'; import AccountLockout from '../AccountLockout'; -import ClassesRouter from './ClassesRouter'; -import rest from '../rest'; -import Auth from '../Auth'; +import ClassesRouter from './ClassesRouter'; +import rest from '../rest'; +import Auth from '../Auth'; import passwordCrypto from '../password'; export class UsersRouter extends ClassesRouter { @@ -18,7 +18,7 @@ export class UsersRouter extends ClassesRouter { * Removes all "_" prefixed properties from an object, except "__type" * @param {Object} obj An object. */ - static removeHiddenProperties (obj) { + static removeHiddenProperties(obj) { for (var key in obj) { if (obj.hasOwnProperty(key)) { // Regexp comes from Parse.Object.prototype.validate @@ -29,9 +29,108 @@ export class UsersRouter extends ClassesRouter { } } + /** + * Validates a password request in login and verifyPassword + * @param {Object} req The request + * @returns {Object} User object + * @private + */ + _authenticateUserFromRequest(req) { + return new Promise((resolve, reject) => { + // Use query parameters instead if provided in url + let payload = req.body; + if (!payload.username && req.query.username || !payload.email && req.query.email) { + payload = req.query; + } + const { + username, + email, + password, + } = payload; + + // TODO: use the right error codes / descriptions. + if (!username && !email) { + throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'username/email is required.'); + } + if (!password) { + throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required.'); + } + if (typeof password !== 'string' + || email && typeof email !== 'string' + || username && typeof username !== 'string') { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + + let user; + let isValidPassword = false; + let query; + if (email && username) { + query = { email, username }; + } else if (email) { + query = { email }; + } else { + query = { $or: [{ username }, { email: username }] }; + } + return req.config.database.find('_User', query) + .then((results) => { + if (!results.length) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + + if (results.length > 1) { // corner case where user1 has username == user2 email + req.config.loggerController.warn('There is a user which email is the same as another user\'s username, logging in based on username'); + user = results.filter((user) => user.username === username)[0]; + } else { + user = results[0]; + } + + return passwordCrypto.compare(password, user.password); + }) + .then((correct) => { + isValidPassword = correct; + const accountLockoutPolicy = new AccountLockout(user, req.config); + return accountLockoutPolicy.handleLoginAttempt(isValidPassword); + }) + .then(() => { + if (!isValidPassword) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + // Ensure the user isn't locked out + // A locked out user won't be able to login + // To lock a user out, just set the ACL to `masterKey` only ({}). + // Empty ACL is OK + if (!req.auth.isMaster && user.ACL && Object.keys(user.ACL).length == 0) { + throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); + } + if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) { + throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.'); + } + + delete user.password; + + // Sometimes the authData still has null on that keys + // https://github.com/parse-community/parse-server/issues/935 + if (user.authData) { + Object.keys(user.authData).forEach((provider) => { + if (user.authData[provider] === null) { + delete user.authData[provider]; + } + }); + if (Object.keys(user.authData).length == 0) { + delete user.authData; + } + } + + return resolve(user); + }).catch((error) => { + return reject(error); + }); + }); + } + handleMe(req) { if (!req.info || !req.info.sessionToken) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } const sessionToken = req.info.sessionToken; return rest.find(req.config, Auth.master(req.config), '_Session', @@ -41,7 +140,7 @@ export class UsersRouter extends ClassesRouter { if (!response.results || response.results.length == 0 || !response.results[0].user) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } else { const user = response.results[0].user; // Send token back on the login, because SDKs expect that. @@ -56,67 +155,11 @@ export class UsersRouter extends ClassesRouter { } handleLogIn(req) { - // Use query parameters instead if provided in url - let payload = req.body; - if (!payload.username && req.query.username || !payload.email && req.query.email) { - payload = req.query; - } - const { - username, - email, - password, - } = payload; - - // TODO: use the right error codes / descriptions. - if (!username && !email) { - throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'username/email is required.'); - } - if (!password) { - throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'password is required.'); - } - if (typeof password !== 'string' - || email && typeof email !== 'string' - || username && typeof username !== 'string') { - throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); - } - let user; - let isValidPassword = false; - let query; - if (email && username) { - query = { email, username }; - } else if (email) { - query = { email }; - } else { - query = { $or: [{ username } , { email: username }] }; - } - return req.config.database.find('_User', query) - .then((results) => { - if (!results.length) { - throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); - } + return this._authenticateUserFromRequest(req) + .then((res) => { - if (results.length > 1) { // corner case where user1 has username == user2 email - req.config.loggerController.warn('There is a user which email is the same as another user\'s username, logging in based on username'); - user = results.filter((user) => user.username === username)[0]; - } else { - user = results[0]; - } - - if (req.config.verifyUserEmails && req.config.preventLoginWithUnverifiedEmail && !user.emailVerified) { - throw new Parse.Error(Parse.Error.EMAIL_NOT_FOUND, 'User email is not verified.'); - } - return passwordCrypto.compare(password, user.password); - }) - .then((correct) => { - isValidPassword = correct; - const accountLockoutPolicy = new AccountLockout(user, req.config); - return accountLockoutPolicy.handleLoginAttempt(isValidPassword); - }) - .then(() => { - if (!isValidPassword) { - throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid username/password.'); - } + user = res; // handle password expiry policy if (req.config.passwordPolicy && req.config.passwordPolicy.maxPasswordAge) { @@ -126,8 +169,8 @@ export class UsersRouter extends ClassesRouter { // password was created before expiry policy was enabled. // simply update _User object so that it will start enforcing from now changedAt = new Date(); - req.config.database.update('_User', {username: user.username}, - {_password_changed_at: Parse._encode(changedAt)}); + req.config.database.update('_User', { username: user.username }, + { _password_changed_at: Parse._encode(changedAt) }); } else { // check whether the password has expired if (changedAt.__type == 'Date') { @@ -140,43 +183,45 @@ export class UsersRouter extends ClassesRouter { } } - delete user.password; - // Remove hidden properties. UsersRouter.removeHiddenProperties(user); - // Sometimes the authData still has null on that keys - // https://github.com/parse-community/parse-server/issues/935 - if (user.authData) { - Object.keys(user.authData).forEach((provider) => { - if (user.authData[provider] === null) { - delete user.authData[provider]; - } - }); - if (Object.keys(user.authData).length == 0) { - delete user.authData; - } - } const { sessionData, createSession - } = Auth.createSession(req.config, { userId: user.objectId, createdWith: { - 'action': 'login', - 'authProvider': 'password' - }, installationId: req.info.installationId }); + } = Auth.createSession(req.config, { + userId: user.objectId, createdWith: { + 'action': 'login', + 'authProvider': 'password' + }, installationId: req.info.installationId + }); user.sessionToken = sessionData.sessionToken; req.config.filesController.expandFilesInObject(req.config, user); return createSession(); - }).then(() => { + }) + .then(() => { + return { response: user }; + }); + } + + handleVerifyPassword(req) { + return this._authenticateUserFromRequest(req) + .then((user) => { + + // Remove hidden properties. + UsersRouter.removeHiddenProperties(user); + return { response: user }; + }).catch((error) => { + throw error; }); } handleLogOut(req) { - const success = {response: {}}; + const success = { response: {} }; if (req.info && req.info.sessionToken) { return rest.find(req.config, Auth.master(req.config), '_Session', { sessionToken: req.info.sessionToken }, undefined, req.info.clientSDK @@ -281,6 +326,7 @@ export class UsersRouter extends ClassesRouter { this.route('POST', '/logout', req => { return this.handleLogOut(req); }); this.route('POST', '/requestPasswordReset', req => { return this.handleResetRequest(req); }); this.route('POST', '/verificationEmailRequest', req => { return this.handleVerificationEmailRequest(req); }); + this.route('GET', '/verifyPassword', req => { return this.handleVerifyPassword(req); }); } } diff --git a/src/TestUtils.js b/src/TestUtils.js index b0ebf4cf5b..ef2fdee81e 100644 --- a/src/TestUtils.js +++ b/src/TestUtils.js @@ -1,14 +1,17 @@ import AppCache from './cache'; -//Used by tests -export function destroyAllDataPermanently() { +/** + * Destroys all data in the database + * @param {boolean} fast set to true if it's ok to just drop objects and not indexes. + */ +export function destroyAllDataPermanently(fast) { if (!process.env.TESTING) { throw 'Only supported in test environment'; } return Promise.all(Object.keys(AppCache.cache).map(appId => { const app = AppCache.get(appId); if (app.databaseController) { - return app.databaseController.deleteEverything(); + return app.databaseController.deleteEverything(fast); } else { return Promise.resolve(); } diff --git a/src/middlewares.js b/src/middlewares.js index 18bcaa11a3..aa8f6755e1 100644 --- a/src/middlewares.js +++ b/src/middlewares.js @@ -247,7 +247,7 @@ export function allowCrossDomain(req, res, next) { res.header('Access-Control-Allow-Origin', '*'); res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS'); res.header('Access-Control-Allow-Headers', 'X-Parse-Master-Key, X-Parse-REST-API-Key, X-Parse-Javascript-Key, X-Parse-Application-Id, X-Parse-Client-Version, X-Parse-Session-Token, X-Requested-With, X-Parse-Revocable-Session, Content-Type, X-CSRF-Token'); - + res.header('Access-Control-Expose-Headers', 'X-Parse-Job-Status-Id, X-Parse-Push-Status-Id'); // intercept OPTIONS method if ('OPTIONS' == req.method) { res.sendStatus(200); @@ -284,6 +284,9 @@ export function handleParseErrors(err, req, res, next) { res.status(httpStatus); res.json({ code: err.code, error: err.message }); log.error(err.message, err); + if (req.config && req.config.enableExpressErrorHandler) { + next(err); + } } else if (err.status && err.message) { res.status(err.status); res.json({ error: err.message }); diff --git a/src/rest.js b/src/rest.js index cbfacbcca6..33b22c7378 100644 --- a/src/rest.js +++ b/src/rest.js @@ -8,7 +8,6 @@ // things. var Parse = require('parse/node').Parse; -import Auth from './Auth'; var RestQuery = require('./RestQuery'); var RestWrite = require('./RestWrite'); @@ -54,9 +53,9 @@ function del(config, auth, className, objectId) { 'bad objectId'); } - if (className === '_User' && !auth.couldUpdateUserId(objectId)) { + if (className === '_User' && auth.isUnauthenticated()) { throw new Parse.Error(Parse.Error.SESSION_MISSING, - 'insufficient auth to delete user'); + 'Insufficient auth to delete user'); } enforceRoleSecurity('delete', className, auth); @@ -67,14 +66,16 @@ function del(config, auth, className, objectId) { const hasTriggers = checkTriggers(className, config, ['beforeDelete', 'afterDelete']); const hasLiveQuery = checkLiveQuery(className, config); if (hasTriggers || hasLiveQuery || className == '_Session') { - return find(config, Auth.master(config), className, {objectId: objectId}) + return new RestQuery(config, auth, className, { objectId }) + .forWrite() + .execute() .then((response) => { if (response && response.results && response.results.length) { const firstResult = response.results[0]; firstResult.className = className; if (className === '_Session' && !auth.isMaster) { if (!auth.user || firstResult.user.objectId !== auth.user.id) { - throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'invalid session token'); + throw new Parse.Error(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token'); } } var cacheAdapter = config.cacheController; @@ -110,6 +111,8 @@ function del(config, auth, className, objectId) { }, options); }).then(() => { return triggers.maybeRunTrigger(triggers.Types.afterDelete, auth, inflatedObject, null, config); + }).catch((error) => { + handleSessionMissingError(error, className, auth); }); } @@ -130,20 +133,33 @@ function update(config, auth, className, restWhere, restObject, clientSDK) { const hasTriggers = checkTriggers(className, config, ['beforeSave', 'afterSave']); const hasLiveQuery = checkLiveQuery(className, config); if (hasTriggers || hasLiveQuery) { - return find(config, Auth.master(config), className, restWhere); + // Do not use find, as it runs the before finds + return new RestQuery(config, auth, className, restWhere) + .forWrite() + .execute(); } return Promise.resolve({}); - }).then((response) => { + }).then(({ results }) => { var originalRestObject; - if (response && response.results && response.results.length) { - originalRestObject = response.results[0]; + if (results && results.length) { + originalRestObject = results[0]; } - - var write = new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK); - return write.execute(); + return new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK) + .execute(); + }).catch((error) => { + handleSessionMissingError(error, className, auth); }); } +function handleSessionMissingError(error, className) { + // If we're trying to update a user without / with bad session token + if (className === '_User' + && error.code === Parse.Error.OBJECT_NOT_FOUND) { + throw new Parse.Error(Parse.Error.SESSION_MISSING, 'Insufficient auth.'); + } + throw error; +} + const classesWithMasterOnlyAccess = ['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_JobSchedule']; // Disallowing access to the _Role collection except by master key function enforceRoleSecurity(method, className, auth) { diff --git a/src/triggers.js b/src/triggers.js index f8f0e6e89f..cb9d1b0caf 100644 --- a/src/triggers.js +++ b/src/triggers.js @@ -224,6 +224,9 @@ export function getResponseObject(request, resolve, reject) { }, error: function(code, message) { if (!message) { + if (code instanceof Parse.Error) { + return reject(code) + } message = code; code = Parse.Error.SCRIPT_FAILED; } From 96c51d27ca4a27dc2b4f1df88475967fa95c534b Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 5 Sep 2018 16:30:59 -0300 Subject: [PATCH 04/73] Avoid mongodb warning using useNewUrlParser --- src/Adapters/Storage/Mongo/MongoStorageAdapter.js | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Adapters/Storage/Mongo/MongoStorageAdapter.js b/src/Adapters/Storage/Mongo/MongoStorageAdapter.js index 333efb314c..d057af3981 100644 --- a/src/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/src/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -119,6 +119,7 @@ export class MongoStorageAdapter implements StorageAdapter { this._uri = uri; this._collectionPrefix = collectionPrefix; this._mongoOptions = mongoOptions; + this._mongoOptions.useNewUrlParser = true; // MaxTimeMS is not a global MongoDB client option, it is applied per operation. this._maxTimeMS = mongoOptions.maxTimeMS; From cce9bae7e3fc1ef1c1e1032fd8b34d50dd738017 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 12 Sep 2018 11:28:31 -0300 Subject: [PATCH 05/73] Add background true to MongoCollection --- .gitignore | 2 ++ lib/Adapters/Storage/Mongo/MongoCollection.js | 2 +- src/Adapters/Storage/Mongo/MongoCollection.js | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 8f1edaabbf..37a3c5268d 100644 --- a/.gitignore +++ b/.gitignore @@ -52,3 +52,5 @@ node_modules # Folder created by FileSystemAdapter /files + +*.orig diff --git a/lib/Adapters/Storage/Mongo/MongoCollection.js b/lib/Adapters/Storage/Mongo/MongoCollection.js index 7e9c22c2b6..01a51e74f2 100644 --- a/lib/Adapters/Storage/Mongo/MongoCollection.js +++ b/lib/Adapters/Storage/Mongo/MongoCollection.js @@ -36,7 +36,7 @@ class MongoCollection { var index = {}; index[key] = '2d'; - return this._mongoCollection.createIndex(index) + return this._mongoCollection.createIndex(index, { background: true }) // Retry, but just once. .then(() => this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference })); }); diff --git a/src/Adapters/Storage/Mongo/MongoCollection.js b/src/Adapters/Storage/Mongo/MongoCollection.js index 128395121b..245a03483a 100644 --- a/src/Adapters/Storage/Mongo/MongoCollection.js +++ b/src/Adapters/Storage/Mongo/MongoCollection.js @@ -33,7 +33,7 @@ export default class MongoCollection { var index = {}; index[key] = '2d'; - return this._mongoCollection.createIndex(index) + return this._mongoCollection.createIndex(index, {background: true}) // Retry, but just once. .then(() => this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference })); }); From ed8b34762e6f3d87a28d95347cdde146e9642b91 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 26 Sep 2018 11:41:25 -0300 Subject: [PATCH 06/73] Better push performance --- src/Controllers/PushController.js | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index 8b645a3680..f58fb67ad6 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -4,6 +4,7 @@ import RestWrite from '../RestWrite'; import { master } from '../Auth'; import { pushStatusHandler } from '../StatusHandler'; import { applyDeviceTokenExists } from '../Push/utils'; +import { logger } from '../logger'; export class PushController { @@ -58,6 +59,8 @@ export class PushController { badgeUpdate = () => { // Build a real RestQuery so we can use it in RestWrite const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere); + // change $exists for $ne null for better performance + if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null} return restQuery.buildRestWhere().then(() => { const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate); write.runOptions.many = true; @@ -70,7 +73,15 @@ export class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - return badgeUpdate(); + const promise = badgeUpdate(); + // add this to ignore badge update errors as default + if (!config.stopOnBadgeUpdateError) { + promise.catch(err => { + logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`) + logger.error(err) + }) + } + return promise }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { From ee51f58520982b5dcd996494318c0f527bf9ff9b Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 26 Sep 2018 12:09:08 -0300 Subject: [PATCH 07/73] Better push performance --- lib/Adapters/Storage/Mongo/MongoCollection.js | 2 +- .../Storage/Mongo/MongoStorageAdapter.js | 3 ++- lib/Controllers/PushController.js | 16 ++++++++++++++-- package-lock.json | 14 +++++++------- 4 files changed, 24 insertions(+), 11 deletions(-) diff --git a/lib/Adapters/Storage/Mongo/MongoCollection.js b/lib/Adapters/Storage/Mongo/MongoCollection.js index 2407f49262..d04ad9b414 100644 --- a/lib/Adapters/Storage/Mongo/MongoCollection.js +++ b/lib/Adapters/Storage/Mongo/MongoCollection.js @@ -110,4 +110,4 @@ class MongoCollection { } } exports.default = MongoCollection; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoCollection.js"],"names":["mongodb","require","Collection","MongoCollection","constructor","mongoCollection","_mongoCollection","find","query","skip","limit","sort","keys","maxTimeMS","readPreference","$score","score","$meta","_rawFind","catch","error","code","message","match","key","index","createIndex","then","findOperation","project","toArray","count","countOperation","distinct","field","aggregate","pipeline","insertOne","object","upsertOne","update","upsert","updateOne","updateMany","deleteMany","_ensureSparseUniqueIndexInBackground","indexRequest","Promise","resolve","reject","ensureIndex","unique","background","sparse","drop"],"mappings":"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","file":"MongoCollection.js","sourcesContent":["const mongodb = require('mongodb');\nconst Collection = mongodb.Collection;\n\nexport default class MongoCollection {\n  _mongoCollection:Collection;\n\n  constructor(mongoCollection:Collection) {\n    this._mongoCollection = mongoCollection;\n  }\n\n  // Does a find with \"smart indexing\".\n  // Currently this just means, if it needs a geoindex and there is\n  // none, then build the geoindex.\n  // This could be improved a lot but it's not clear if that's a good\n  // idea. Or even if this behavior is a good idea.\n  find(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) {\n    // Support for Full Text Search - $text\n    if(keys && keys.$score) {\n      delete keys.$score;\n      keys.score = {$meta: 'textScore'};\n    }\n    return this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference })\n      .catch(error => {\n        // Check for \"no geoindex\" error\n        if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {\n          throw error;\n        }\n        // Figure out what key needs an index\n        const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];\n        if (!key) {\n          throw error;\n        }\n\n        var index = {};\n        index[key] = '2d';\n        return this._mongoCollection.createIndex(index)\n          // Retry, but just once.\n          .then(() => this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference }));\n      });\n  }\n\n  _rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) {\n    let findOperation = this._mongoCollection\n      .find(query, { skip, limit, sort, readPreference })\n\n    if (keys) {\n      findOperation = findOperation.project(keys);\n    }\n\n    if (maxTimeMS) {\n      findOperation = findOperation.maxTimeMS(maxTimeMS);\n    }\n\n    return findOperation.toArray();\n  }\n\n  count(query, { skip, limit, sort, maxTimeMS, readPreference } = {}) {\n    const countOperation = this._mongoCollection.count(query, { skip, limit, sort, maxTimeMS, readPreference });\n\n    return countOperation;\n  }\n\n  distinct(field, query) {\n    return this._mongoCollection.distinct(field, query);\n  }\n\n  aggregate(pipeline, { maxTimeMS, readPreference } = {}) {\n    return this._mongoCollection.aggregate(pipeline, { maxTimeMS, readPreference }).toArray();\n  }\n\n  insertOne(object) {\n    return this._mongoCollection.insertOne(object);\n  }\n\n  // Atomically updates data in the database for a single (first) object that matched the query\n  // If there is nothing that matches the query - does insert\n  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.\n  upsertOne(query, update) {\n    return this._mongoCollection.update(query, update, { upsert: true })\n  }\n\n  updateOne(query, update) {\n    return this._mongoCollection.updateOne(query, update);\n  }\n\n  updateMany(query, update) {\n    return this._mongoCollection.updateMany(query, update);\n  }\n\n  deleteMany(query) {\n    return this._mongoCollection.deleteMany(query);\n  }\n\n  _ensureSparseUniqueIndexInBackground(indexRequest) {\n    return new Promise((resolve, reject) => {\n      this._mongoCollection.ensureIndex(indexRequest, { unique: true, background: true, sparse: true }, (error) => {\n        if (error) {\n          reject(error);\n        } else {\n          resolve();\n        }\n      });\n    });\n  }\n\n  drop() {\n    return this._mongoCollection.drop();\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoCollection.js"],"names":["mongodb","require","Collection","MongoCollection","constructor","mongoCollection","_mongoCollection","find","query","skip","limit","sort","keys","maxTimeMS","readPreference","$score","score","$meta","_rawFind","catch","error","code","message","match","key","index","createIndex","background","then","findOperation","project","toArray","count","countOperation","distinct","field","aggregate","pipeline","insertOne","object","upsertOne","update","upsert","updateOne","updateMany","deleteMany","_ensureSparseUniqueIndexInBackground","indexRequest","Promise","resolve","reject","ensureIndex","unique","sparse","drop"],"mappings":"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","file":"MongoCollection.js","sourcesContent":["const mongodb = require('mongodb');\nconst Collection = mongodb.Collection;\n\nexport default class MongoCollection {\n  _mongoCollection:Collection;\n\n  constructor(mongoCollection:Collection) {\n    this._mongoCollection = mongoCollection;\n  }\n\n  // Does a find with \"smart indexing\".\n  // Currently this just means, if it needs a geoindex and there is\n  // none, then build the geoindex.\n  // This could be improved a lot but it's not clear if that's a good\n  // idea. Or even if this behavior is a good idea.\n  find(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) {\n    // Support for Full Text Search - $text\n    if(keys && keys.$score) {\n      delete keys.$score;\n      keys.score = {$meta: 'textScore'};\n    }\n    return this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference })\n      .catch(error => {\n        // Check for \"no geoindex\" error\n        if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {\n          throw error;\n        }\n        // Figure out what key needs an index\n        const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];\n        if (!key) {\n          throw error;\n        }\n\n        var index = {};\n        index[key] = '2d';\n        return this._mongoCollection.createIndex(index, {background: true})\n          // Retry, but just once.\n          .then(() => this._rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference }));\n      });\n  }\n\n  _rawFind(query, { skip, limit, sort, keys, maxTimeMS, readPreference } = {}) {\n    let findOperation = this._mongoCollection\n      .find(query, { skip, limit, sort, readPreference })\n\n    if (keys) {\n      findOperation = findOperation.project(keys);\n    }\n\n    if (maxTimeMS) {\n      findOperation = findOperation.maxTimeMS(maxTimeMS);\n    }\n\n    return findOperation.toArray();\n  }\n\n  count(query, { skip, limit, sort, maxTimeMS, readPreference } = {}) {\n    const countOperation = this._mongoCollection.count(query, { skip, limit, sort, maxTimeMS, readPreference });\n\n    return countOperation;\n  }\n\n  distinct(field, query) {\n    return this._mongoCollection.distinct(field, query);\n  }\n\n  aggregate(pipeline, { maxTimeMS, readPreference } = {}) {\n    return this._mongoCollection.aggregate(pipeline, { maxTimeMS, readPreference }).toArray();\n  }\n\n  insertOne(object) {\n    return this._mongoCollection.insertOne(object);\n  }\n\n  // Atomically updates data in the database for a single (first) object that matched the query\n  // If there is nothing that matches the query - does insert\n  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.\n  upsertOne(query, update) {\n    return this._mongoCollection.update(query, update, { upsert: true })\n  }\n\n  updateOne(query, update) {\n    return this._mongoCollection.updateOne(query, update);\n  }\n\n  updateMany(query, update) {\n    return this._mongoCollection.updateMany(query, update);\n  }\n\n  deleteMany(query) {\n    return this._mongoCollection.deleteMany(query);\n  }\n\n  _ensureSparseUniqueIndexInBackground(indexRequest) {\n    return new Promise((resolve, reject) => {\n      this._mongoCollection.ensureIndex(indexRequest, { unique: true, background: true, sparse: true }, (error) => {\n        if (error) {\n          reject(error);\n        } else {\n          resolve();\n        }\n      });\n    });\n  }\n\n  drop() {\n    return this._mongoCollection.drop();\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js index dbd8421b3c..a1a20c35c1 100644 --- a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -127,6 +127,7 @@ class MongoStorageAdapter { this._uri = uri; this._collectionPrefix = collectionPrefix; this._mongoOptions = mongoOptions; + this._mongoOptions.useNewUrlParser = true; // MaxTimeMS is not a global MongoDB client option, it is applied per operation. this._maxTimeMS = mongoOptions.maxTimeMS; @@ -769,4 +770,4 @@ class MongoStorageAdapter { exports.MongoStorageAdapter = MongoStorageAdapter; exports.default = MongoStorageAdapter; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoStorageAdapter.js"],"names":["mongodb","require","MongoClient","ReadPreference","MongoSchemaCollectionName","storageAdapterAllCollections","mongoAdapter","connect","then","database","collections","filter","collection","namespace","match","collectionName","indexOf","_collectionPrefix","convertParseSchemaToMongoSchema","schema","fields","_rperm","_wperm","className","_hashed_password","mongoSchemaFromFieldsAndClassNameAndCLP","classLevelPermissions","indexes","mongoObject","_id","objectId","updatedAt","createdAt","_metadata","undefined","fieldName","MongoSchemaCollection","parseFieldTypeToMongoFieldType","class_permissions","Object","keys","length","MongoStorageAdapter","constructor","uri","defaults","DefaultMongoURI","collectionPrefix","mongoOptions","_uri","_mongoOptions","_maxTimeMS","maxTimeMS","canSortOnJoinTables","connectionPromise","encodedUri","client","options","s","db","dbName","on","catch","err","Promise","reject","handleError","error","code","logger","handleShutdown","close","_adaptiveCollection","name","rawCollection","MongoCollection","_schemaCollection","classExists","listCollections","toArray","setClassLevelPermissions","CLPs","schemaCollection","updateSchema","$set","setIndexesWithSchemaFormat","submittedIndexes","existingIndexes","resolve","_id_","deletePromises","insertedIndexes","forEach","field","__op","Parse","Error","INVALID_QUERY","promise","dropIndex","push","key","hasOwnProperty","insertPromise","createIndexes","all","setIndexesFromMongo","getIndexes","reduce","obj","index","_fts","_ftsx","weights","createClass","insertSchema","addFieldIfNotExists","type","createIndexesIfNeeded","deleteClass","drop","message","findAndDeleteSchema","deleteAllClasses","fast","map","remove","deleteFields","fieldNames","mongoFormatNames","collectionUpdate","schemaUpdate","updateMany","getAllClasses","schemasCollection","_fetchAllSchemasFrom_SCHEMA","getClass","_fetchOneSchemaFrom_SCHEMA","createObject","object","insertOne","DUPLICATE_VALUE","underlyingError","matches","Array","isArray","userInfo","duplicated_field","deleteObjectsByQuery","query","mongoWhere","deleteMany","result","n","OBJECT_NOT_FOUND","INTERNAL_SERVER_ERROR","updateObjectsByQuery","update","mongoUpdate","findOneAndUpdate","_mongoCollection","findAndModify","new","value","upsertOneObject","upsertOne","find","skip","limit","sort","readPreference","mongoSort","_","mapKeys","mongoKeys","memo","_parseReadPreference","createTextIndexesIfNeeded","objects","ensureUniqueness","indexCreationRequest","mongoFieldNames","_ensureSparseUniqueIndexInBackground","_rawFind","count","distinct","isPointerField","substring","aggregate","pipeline","stage","$group","_parseAggregateGroupArgs","$match","_parseAggregateArgs","$project","_parseAggregateProjectArgs","results","split","isEmpty","returnValue","targetClass","_convertToDate","Date","PRIMARY","PRIMARY_PREFERRED","SECONDARY","SECONDARY_PREFERRED","NEAREST","performInitialization","createIndex","background","$text","indexName","textIndex","dropAllIndexes","dropIndexes","updateSchemaWithIndexes","classes","promises"],"mappings":"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","file":"MongoStorageAdapter.js","sourcesContent":["// @flow\nimport MongoCollection       from './MongoCollection';\nimport MongoSchemaCollection from './MongoSchemaCollection';\nimport { StorageAdapter }    from '../StorageAdapter';\nimport type { SchemaType,\n  QueryType,\n  StorageClass,\n  QueryOptions } from '../StorageAdapter';\nimport {\n  parse as parseUrl,\n  format as formatUrl,\n} from '../../../vendor/mongodbUrl';\nimport {\n  parseObjectToMongoObjectForCreate,\n  mongoObjectToParseObject,\n  transformKey,\n  transformWhere,\n  transformUpdate,\n  transformPointerString,\n} from './MongoTransform';\n// @flow-disable-next\nimport Parse                 from 'parse/node';\n// @flow-disable-next\nimport _                     from 'lodash';\nimport defaults              from '../../../defaults';\nimport logger                from '../../../logger';\n\n// @flow-disable-next\nconst mongodb = require('mongodb');\nconst MongoClient = mongodb.MongoClient;\nconst ReadPreference = mongodb.ReadPreference;\n\nconst MongoSchemaCollectionName = '_SCHEMA';\n\nconst storageAdapterAllCollections = mongoAdapter => {\n  return mongoAdapter.connect()\n    .then(() => mongoAdapter.database.collections())\n    .then(collections => {\n      return collections.filter(collection => {\n        if (collection.namespace.match(/\\.system\\./)) {\n          return false;\n        }\n        // TODO: If you have one app with a collection prefix that happens to be a prefix of another\n        // apps prefix, this will go very very badly. We should fix that somehow.\n        return (collection.collectionName.indexOf(mongoAdapter._collectionPrefix) == 0);\n      });\n    });\n}\n\nconst convertParseSchemaToMongoSchema = ({...schema}) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  if (schema.className === '_User') {\n    // Legacy mongo adapter knows about the difference between password and _hashed_password.\n    // Future database adapters will only know about _hashed_password.\n    // Note: Parse Server will bring back password with injectDefaultSchema, so we don't need\n    // to add _hashed_password back ever.\n    delete schema.fields._hashed_password;\n  }\n\n  return schema;\n}\n\n// Returns { code, error } if invalid, or { result }, an object\n// suitable for inserting into _SCHEMA collection, otherwise.\nconst mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPermissions, indexes) => {\n  const mongoObject = {\n    _id: className,\n    objectId: 'string',\n    updatedAt: 'string',\n    createdAt: 'string',\n    _metadata: undefined,\n  };\n\n  for (const fieldName in fields) {\n    mongoObject[fieldName] = MongoSchemaCollection.parseFieldTypeToMongoFieldType(fields[fieldName]);\n  }\n\n  if (typeof classLevelPermissions !== 'undefined') {\n    mongoObject._metadata = mongoObject._metadata || {};\n    if (!classLevelPermissions) {\n      delete mongoObject._metadata.class_permissions;\n    } else {\n      mongoObject._metadata.class_permissions = classLevelPermissions;\n    }\n  }\n\n  if (indexes && typeof indexes === 'object' && Object.keys(indexes).length > 0) {\n    mongoObject._metadata = mongoObject._metadata || {};\n    mongoObject._metadata.indexes = indexes;\n  }\n\n  if (!mongoObject._metadata) { // cleanup the unused _metadata\n    delete mongoObject._metadata;\n  }\n\n  return mongoObject;\n}\n\n\nexport class MongoStorageAdapter implements StorageAdapter {\n  // Private\n  _uri: string;\n  _collectionPrefix: string;\n  _mongoOptions: Object;\n  // Public\n  connectionPromise: Promise<any>;\n  database: any;\n  client: MongoClient;\n  _maxTimeMS: ?number;\n  canSortOnJoinTables: boolean;\n\n  constructor({\n    uri = defaults.DefaultMongoURI,\n    collectionPrefix = '',\n    mongoOptions = {},\n  }: any) {\n    this._uri = uri;\n    this._collectionPrefix = collectionPrefix;\n    this._mongoOptions = mongoOptions;\n\n    // MaxTimeMS is not a global MongoDB client option, it is applied per operation.\n    this._maxTimeMS = mongoOptions.maxTimeMS;\n    this.canSortOnJoinTables = true;\n    delete mongoOptions.maxTimeMS;\n  }\n\n  connect() {\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    // parsing and re-formatting causes the auth value (if there) to get URI\n    // encoded\n    const encodedUri = formatUrl(parseUrl(this._uri));\n\n    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(client => {\n      // Starting mongoDB 3.0, the MongoClient.connect don't return a DB anymore but a client\n      // Fortunately, we can get back the options and use them to select the proper DB.\n      // https://github.com/mongodb/node-mongodb-native/blob/2c35d76f08574225b8db02d7bef687123e6bb018/lib/mongo_client.js#L885\n      const options = client.s.options;\n      const database = client.db(options.dbName);\n      if (!database) {\n        delete this.connectionPromise;\n        return;\n      }\n      database.on('error', () => {\n        delete this.connectionPromise;\n      });\n      database.on('close', () => {\n        delete this.connectionPromise;\n      });\n      this.client = client;\n      this.database = database;\n    }).catch((err) => {\n      delete this.connectionPromise;\n      return Promise.reject(err);\n    });\n\n    return this.connectionPromise;\n  }\n\n  handleError<T>(error: ?(Error | Parse.Error)): Promise<T> {\n    if (error && error.code === 13) { // Unauthorized error\n      delete this.client;\n      delete this.database;\n      delete this.connectionPromise;\n      logger.error('Received unauthorized error', { error: error });\n    }\n    throw error;\n  }\n\n  handleShutdown() {\n    if (!this.client) {\n      return;\n    }\n    this.client.close(false);\n  }\n\n  _adaptiveCollection(name: string) {\n    return this.connect()\n      .then(() => this.database.collection(this._collectionPrefix + name))\n      .then(rawCollection => new MongoCollection(rawCollection))\n      .catch(err => this.handleError(err));\n  }\n\n  _schemaCollection(): Promise<MongoSchemaCollection> {\n    return this.connect()\n      .then(() => this._adaptiveCollection(MongoSchemaCollectionName))\n      .then(collection => new MongoSchemaCollection(collection));\n  }\n\n  classExists(name: string) {\n    return this.connect().then(() => {\n      return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();\n    }).then(collections => {\n      return collections.length > 0;\n    }).catch(err => this.handleError(err));\n  }\n\n  setClassLevelPermissions(className: string, CLPs: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.class_permissions': CLPs }\n      })).catch(err => this.handleError(err));\n  }\n\n  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any): Promise<void> {\n    if (submittedIndexes === undefined) {\n      return Promise.resolve();\n    }\n    if (Object.keys(existingIndexes).length === 0) {\n      existingIndexes = { _id_: { _id: 1} };\n    }\n    const deletePromises = [];\n    const insertedIndexes = [];\n    Object.keys(submittedIndexes).forEach(name => {\n      const field = submittedIndexes[name];\n      if (existingIndexes[name] && field.__op !== 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`);\n      }\n      if (!existingIndexes[name] && field.__op === 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`);\n      }\n      if (field.__op === 'Delete') {\n        const promise = this.dropIndex(className, name);\n        deletePromises.push(promise);\n        delete existingIndexes[name];\n      } else {\n        Object.keys(field).forEach(key => {\n          if (!fields.hasOwnProperty(key)) {\n            throw new Parse.Error(Parse.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`);\n          }\n        });\n        existingIndexes[name] = field;\n        insertedIndexes.push({\n          key: field,\n          name,\n        });\n      }\n    });\n    let insertPromise = Promise.resolve();\n    if (insertedIndexes.length > 0) {\n      insertPromise = this.createIndexes(className, insertedIndexes);\n    }\n    return Promise.all(deletePromises)\n      .then(() => insertPromise)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.indexes':  existingIndexes }\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  setIndexesFromMongo(className: string) {\n    return this.getIndexes(className).then((indexes) => {\n      indexes = indexes.reduce((obj, index) => {\n        if (index.key._fts) {\n          delete index.key._fts;\n          delete index.key._ftsx;\n          for (const field in index.weights) {\n            index.key[field] = 'text';\n          }\n        }\n        obj[index.name] = index.key;\n        return obj;\n      }, {});\n      return this._schemaCollection()\n        .then(schemaCollection => schemaCollection.updateSchema(className, {\n          $set: { '_metadata.indexes': indexes }\n        }));\n    })\n      .catch(err => this.handleError(err))\n      .catch(() => {\n        // Ignore if collection not found\n        return Promise.resolve();\n      });\n  }\n\n  createClass(className: string, schema: SchemaType): Promise<void> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions, schema.indexes);\n    mongoObject._id = className;\n    return this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.insertSchema(mongoObject))\n      .catch(err => this.handleError(err));\n  }\n\n  addFieldIfNotExists(className: string, fieldName: string, type: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type))\n      .then(() => this.createIndexesIfNeeded(className, fieldName, type))\n      .catch(err => this.handleError(err));\n  }\n\n  // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)\n  // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.\n  deleteClass(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection.drop())\n      .catch(error => {\n      // 'ns not found' means collection was already gone. Ignore deletion attempt.\n        if (error.message == 'ns not found') {\n          return;\n        }\n        throw error;\n      })\n    // We've dropped the collection, now remove the _SCHEMA document\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.findAndDeleteSchema(className))\n      .catch(err => this.handleError(err));\n  }\n\n  deleteAllClasses(fast: boolean) {\n    return storageAdapterAllCollections(this)\n      .then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop())));\n  }\n\n  // Remove the column and all the data. For Relations, the _Join collection is handled\n  // specially, this function does not delete _Join columns. It should, however, indicate\n  // that the relation fields does not exist anymore. In mongo, this means removing it from\n  // the _SCHEMA collection.  There should be no actual data in the collection under the same name\n  // as the relation column, so it's fine to attempt to delete it. If the fields listed to be\n  // deleted do not exist, this function should return successfully anyways. Checking for\n  // attempts to delete non-existent fields is the responsibility of Parse Server.\n\n  // Pointer field names are passed for legacy reasons: the original mongo\n  // format stored pointer field names differently in the database, and therefore\n  // needed to know the type of the field before it could delete it. Future database\n  // adapters should ignore the pointerFieldNames argument. All the field names are in\n  // fieldNames, they show up additionally in the pointerFieldNames database for use\n  // by the mongo adapter, which deals with the legacy mongo format.\n\n  // This function is not obligated to delete fields atomically. It is given the field\n  // names in a list so that databases that are capable of deleting fields atomically\n  // may do so.\n\n  // Returns a Promise.\n  deleteFields(className: string, schema: SchemaType, fieldNames: string[]) {\n    const mongoFormatNames = fieldNames.map(fieldName => {\n      if (schema.fields[fieldName].type === 'Pointer') {\n        return `_p_${fieldName}`\n      } else {\n        return fieldName;\n      }\n    });\n    const collectionUpdate = { '$unset' : {} };\n    mongoFormatNames.forEach(name => {\n      collectionUpdate['$unset'][name] = null;\n    });\n\n    const schemaUpdate = { '$unset' : {} };\n    fieldNames.forEach(name => {\n      schemaUpdate['$unset'][name] = null;\n    });\n\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany({}, collectionUpdate))\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for all schemas known to this adapter, in Parse format. In case the\n  // schemas cannot be retrieved, returns a promise that rejects. Requirements for the\n  // rejection reason are TBD.\n  getAllClasses(): Promise<StorageClass[]> {\n    return this._schemaCollection().then(schemasCollection => schemasCollection._fetchAllSchemasFrom_SCHEMA())\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for the schema with the given name, in Parse format. If\n  // this adapter doesn't know about the schema, return a promise that rejects with\n  // undefined as the reason.\n  getClass(className: string): Promise<StorageClass> {\n    return this._schemaCollection()\n      .then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className))\n      .catch(err => this.handleError(err));\n  }\n\n  // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema,\n  // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs\n  // the schema only for the legacy mongo format. We'll figure that out later.\n  createObject(className: string, schema: SchemaType, object: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = parseObjectToMongoObjectForCreate(className, object, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.insertOne(mongoObject))\n      .catch(error => {\n        if (error.code === 11000) { // Duplicate value\n          const err = new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          err.underlyingError = error;\n          if (error.message) {\n            const matches = error.message.match(/index:[\\sa-zA-Z0-9_\\-\\.]+\\$?([a-zA-Z_-]+)_1/);\n            if (matches && Array.isArray(matches)) {\n              err.userInfo = { duplicated_field: matches[1] };\n            }\n          }\n          throw err;\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Remove all objects that match the given Parse Query.\n  // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.\n  // If there is some other error, reject with INTERNAL_SERVER_ERROR.\n  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    return this._adaptiveCollection(className)\n      .then(collection => {\n        const mongoWhere = transformWhere(className, query, schema);\n        return collection.deleteMany(mongoWhere)\n      })\n      .catch(err => this.handleError(err))\n      .then(({ result }) => {\n        if (result.n === 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n        return Promise.resolve();\n      }, () => {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error');\n      });\n  }\n\n  // Apply the update to all objects that match the given Parse Query.\n  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Atomically finds and updates an object based on query.\n  // Return value not currently well specified.\n  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.findAndModify(mongoWhere, [], mongoUpdate, { new: true }))\n      .then(result => mongoObjectToParseObject(className, result.value, schema))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Hopefully we can get rid of this. It's only used for config and hooks.\n  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.upsertOne(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.\n  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptions): Promise<any> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));\n    const mongoKeys = _.reduce(keys, (memo, key) => {\n      memo[transformKey(className, key, schema)] = 1;\n      return memo;\n    }, {});\n\n    readPreference = this._parseReadPreference(readPreference);\n    return this.createTextIndexesIfNeeded(className, query, schema)\n      .then(() => this._adaptiveCollection(className))\n      .then(collection => collection.find(mongoWhere, {\n        skip,\n        limit,\n        sort: mongoSort,\n        keys: mongoKeys,\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't\n  // currently know which fields are nullable and which aren't, we ignore that criteria.\n  // As such, we shouldn't expose this function to users of parse until we have an out-of-band\n  // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,\n  // which is why we use sparse indexes.\n  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const indexCreationRequest = {};\n    const mongoFieldNames = fieldNames.map(fieldName => transformKey(className, fieldName, schema));\n    mongoFieldNames.forEach(fieldName => {\n      indexCreationRequest[fieldName] = 1;\n    });\n    return this._adaptiveCollection(className)\n      .then(collection => collection._ensureSparseUniqueIndexInBackground(indexCreationRequest))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Tried to ensure field uniqueness for a class that already has duplicates.');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Used in tests\n  _rawFind(className: string, query: QueryType) {\n    return this._adaptiveCollection(className).then(collection => collection.find(query, {\n      maxTimeMS: this._maxTimeMS,\n    })).catch(err => this.handleError(err));\n  }\n\n  // Executes a count.\n  count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.count(transformWhere(className, query, schema), {\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const isPointerField = schema.fields[fieldName] && schema.fields[fieldName].type === 'Pointer';\n    if (isPointerField) {\n      fieldName = `_p_${fieldName}`\n    }\n    return this._adaptiveCollection(className)\n      .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)))\n      .then(objects => {\n        objects = objects.filter((obj) => obj != null);\n        return objects.map(object => {\n          if (isPointerField) {\n            const field = fieldName.substring(3);\n            return transformPointerString(schema, field, object);\n          }\n          return mongoObjectToParseObject(className, object, schema);\n        });\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) {\n    let isPointerField = false;\n    pipeline = pipeline.map((stage) => {\n      if (stage.$group) {\n        stage.$group = this._parseAggregateGroupArgs(schema, stage.$group);\n        if (stage.$group._id && (typeof stage.$group._id === 'string') && stage.$group._id.indexOf('$_p_') >= 0) {\n          isPointerField = true;\n        }\n      }\n      if (stage.$match) {\n        stage.$match = this._parseAggregateArgs(schema, stage.$match);\n      }\n      if (stage.$project) {\n        stage.$project = this._parseAggregateProjectArgs(schema, stage.$project);\n      }\n      return stage;\n    });\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS }))\n      .catch(error => {\n        if (error.code === 16006) {\n          throw new Parse.Error(Parse.Error.INVALID_QUERY, error.message);\n        }\n        throw error;\n      })\n      .then(results => {\n        results.forEach(result => {\n          if (result.hasOwnProperty('_id')) {\n            if (isPointerField && result._id) {\n              result._id = result._id.split('$')[1];\n            }\n            if (result._id == null || _.isEmpty(result._id)) {\n              result._id = null;\n            }\n            result.objectId = result._id;\n            delete result._id;\n          }\n        });\n        return results;\n      })\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // This function will recursively traverse the pipeline and convert any Pointer or Date columns.\n  // If we detect a pointer column we will rename the column being queried for to match the column\n  // in the database. We also modify the value to what we expect the value to be in the database\n  // as well.\n  // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert\n  // the string to a Date so the driver can perform the necessary comparison.\n  //\n  // The goal of this method is to look for the \"leaves\" of the pipeline and determine if it needs\n  // to be converted. The pipeline can have a few different forms. For more details, see:\n  //     https://docs.mongodb.com/manual/reference/operator/aggregation/\n  //\n  // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In\n  // that case we need to loop through all of it's children to find the columns being operated on.\n  // If the pipeline is an object, then we'll loop through the keys checking to see if the key name\n  // matches one of the schema columns. If it does match a column and the column is a Pointer or\n  // a Date, then we'll convert the value as described above.\n  //\n  // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing\n  // down a tree to find a \"leaf node\" and checking to see if it needs to be converted.\n  _parseAggregateArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n          if (typeof pipeline[field] === 'object') {\n            // Pass objects down to MongoDB...this is more than likely an $exists operator.\n            returnValue[`_p_${field}`] = pipeline[field];\n          } else {\n            returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`;\n          }\n        } else if (schema.fields[field] && schema.fields[field].type === 'Date') {\n          returnValue[field] = this._convertToDate(pipeline[field]);\n        } else {\n          returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n        }\n\n        if (field === 'objectId') {\n          returnValue['_id'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'createdAt') {\n          returnValue['_created_at'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'updatedAt') {\n          returnValue['_updated_at'] = returnValue[field];\n          delete returnValue[field];\n        }\n      }\n      return returnValue;\n    }\n    return pipeline;\n  }\n\n  // This function is slightly different than the one above. Rather than trying to combine these\n  // two functions and making the code even harder to understand, I decided to split it up. The\n  // difference with this function is we are not transforming the values, only the keys of the\n  // pipeline.\n  _parseAggregateProjectArgs(schema: any, pipeline: any): any {\n    const returnValue = {};\n    for (const field in pipeline) {\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        returnValue[`_p_${field}`] = pipeline[field];\n      } else {\n        returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n      }\n\n      if (field === 'objectId') {\n        returnValue['_id'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'createdAt') {\n        returnValue['_created_at'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'updatedAt') {\n        returnValue['_updated_at'] = returnValue[field];\n        delete returnValue[field];\n      }\n    }\n    return returnValue;\n  }\n\n  // This function is slightly different than the two above. MongoDB $group aggregate looks like:\n  //     { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }\n  // The <expression> could be a column name, prefixed with the '$' character. We'll look for\n  // these <expression> and check to see if it is a 'Pointer' or if it's one of createdAt,\n  // updatedAt or objectId and change it accordingly.\n  _parseAggregateGroupArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateGroupArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]);\n      }\n      return returnValue;\n    } else if (typeof pipeline === 'string') {\n      const field = pipeline.substring(1);\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        return `$_p_${field}`;\n      } else if (field == 'createdAt') {\n        return '$_created_at';\n      } else if (field == 'updatedAt') {\n        return '$_updated_at';\n      }\n    }\n    return pipeline;\n  }\n\n  // This function will attempt to convert the provided value to a Date object. Since this is part\n  // of an aggregation pipeline, the value can either be a string or it can be another object with\n  // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a\n  // recursive method to traverse down to the \"leaf node\" which is going to be the string.\n  _convertToDate(value: any): any {\n    if (typeof value === 'string') {\n      return new Date(value);\n    }\n\n    const returnValue = {}\n    for (const field in value) {\n      returnValue[field] = this._convertToDate(value[field])\n    }\n    return returnValue;\n  }\n\n  _parseReadPreference(readPreference: ?string): ?string {\n    switch (readPreference) {\n    case 'PRIMARY':\n      readPreference = ReadPreference.PRIMARY;\n      break;\n    case 'PRIMARY_PREFERRED':\n      readPreference = ReadPreference.PRIMARY_PREFERRED;\n      break;\n    case 'SECONDARY':\n      readPreference = ReadPreference.SECONDARY;\n      break;\n    case 'SECONDARY_PREFERRED':\n      readPreference = ReadPreference.SECONDARY_PREFERRED;\n      break;\n    case 'NEAREST':\n      readPreference = ReadPreference.NEAREST;\n      break;\n    case undefined:\n      break;\n    default:\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');\n    }\n    return readPreference;\n  }\n\n  performInitialization(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  createIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndex(index, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexes(className: string, indexes: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndexes(indexes, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexesIfNeeded(className: string, fieldName: string, type: any) {\n    if (type && type.type === 'Polygon') {\n      const index = {\n        [fieldName]: '2dsphere'\n      };\n      return this.createIndex(className, index);\n    }\n    return Promise.resolve();\n  }\n\n  createTextIndexesIfNeeded(className: string, query: QueryType, schema: any): Promise<void> {\n    for(const fieldName in query) {\n      if (!query[fieldName] || !query[fieldName].$text) {\n        continue;\n      }\n      const existingIndexes = schema.indexes;\n      for (const key in existingIndexes) {\n        const index = existingIndexes[key];\n        if (index.hasOwnProperty(fieldName)) {\n          return Promise.resolve();\n        }\n      }\n      const indexName = `${fieldName}_text`;\n      const textIndex = {\n        [indexName]: { [fieldName]: 'text' }\n      };\n      return this.setIndexesWithSchemaFormat(className, textIndex, existingIndexes, schema.fields)\n        .catch((error) => {\n          if (error.code === 85) { // Index exist with different options\n            return this.setIndexesFromMongo(className);\n          }\n          throw error;\n        });\n    }\n    return Promise.resolve();\n  }\n\n  getIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.indexes())\n      .catch(err => this.handleError(err));\n  }\n\n  dropIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndex(index))\n      .catch(err => this.handleError(err));\n  }\n\n  dropAllIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndexes())\n      .catch(err => this.handleError(err));\n  }\n\n  updateSchemaWithIndexes(): Promise<any> {\n    return this.getAllClasses()\n      .then((classes) => {\n        const promises = classes.map((schema) => {\n          return this.setIndexesFromMongo(schema.className);\n        });\n        return Promise.all(promises);\n      })\n      .catch(err => this.handleError(err));\n  }\n}\n\nexport default MongoStorageAdapter;\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoStorageAdapter.js"],"names":["mongodb","require","MongoClient","ReadPreference","MongoSchemaCollectionName","storageAdapterAllCollections","mongoAdapter","connect","then","database","collections","filter","collection","namespace","match","collectionName","indexOf","_collectionPrefix","convertParseSchemaToMongoSchema","schema","fields","_rperm","_wperm","className","_hashed_password","mongoSchemaFromFieldsAndClassNameAndCLP","classLevelPermissions","indexes","mongoObject","_id","objectId","updatedAt","createdAt","_metadata","undefined","fieldName","MongoSchemaCollection","parseFieldTypeToMongoFieldType","class_permissions","Object","keys","length","MongoStorageAdapter","constructor","uri","defaults","DefaultMongoURI","collectionPrefix","mongoOptions","_uri","_mongoOptions","useNewUrlParser","_maxTimeMS","maxTimeMS","canSortOnJoinTables","connectionPromise","encodedUri","client","options","s","db","dbName","on","catch","err","Promise","reject","handleError","error","code","logger","handleShutdown","close","_adaptiveCollection","name","rawCollection","MongoCollection","_schemaCollection","classExists","listCollections","toArray","setClassLevelPermissions","CLPs","schemaCollection","updateSchema","$set","setIndexesWithSchemaFormat","submittedIndexes","existingIndexes","resolve","_id_","deletePromises","insertedIndexes","forEach","field","__op","Parse","Error","INVALID_QUERY","promise","dropIndex","push","key","hasOwnProperty","insertPromise","createIndexes","all","setIndexesFromMongo","getIndexes","reduce","obj","index","_fts","_ftsx","weights","createClass","insertSchema","addFieldIfNotExists","type","createIndexesIfNeeded","deleteClass","drop","message","findAndDeleteSchema","deleteAllClasses","fast","map","remove","deleteFields","fieldNames","mongoFormatNames","collectionUpdate","schemaUpdate","updateMany","getAllClasses","schemasCollection","_fetchAllSchemasFrom_SCHEMA","getClass","_fetchOneSchemaFrom_SCHEMA","createObject","object","insertOne","DUPLICATE_VALUE","underlyingError","matches","Array","isArray","userInfo","duplicated_field","deleteObjectsByQuery","query","mongoWhere","deleteMany","result","n","OBJECT_NOT_FOUND","INTERNAL_SERVER_ERROR","updateObjectsByQuery","update","mongoUpdate","findOneAndUpdate","_mongoCollection","findAndModify","new","value","upsertOneObject","upsertOne","find","skip","limit","sort","readPreference","mongoSort","_","mapKeys","mongoKeys","memo","_parseReadPreference","createTextIndexesIfNeeded","objects","ensureUniqueness","indexCreationRequest","mongoFieldNames","_ensureSparseUniqueIndexInBackground","_rawFind","count","distinct","isPointerField","substring","aggregate","pipeline","stage","$group","_parseAggregateGroupArgs","$match","_parseAggregateArgs","$project","_parseAggregateProjectArgs","results","split","isEmpty","returnValue","targetClass","_convertToDate","Date","PRIMARY","PRIMARY_PREFERRED","SECONDARY","SECONDARY_PREFERRED","NEAREST","performInitialization","createIndex","background","$text","indexName","textIndex","dropAllIndexes","dropIndexes","updateSchemaWithIndexes","classes","promises"],"mappings":"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","file":"MongoStorageAdapter.js","sourcesContent":["// @flow\nimport MongoCollection       from './MongoCollection';\nimport MongoSchemaCollection from './MongoSchemaCollection';\nimport { StorageAdapter }    from '../StorageAdapter';\nimport type { SchemaType,\n  QueryType,\n  StorageClass,\n  QueryOptions } from '../StorageAdapter';\nimport {\n  parse as parseUrl,\n  format as formatUrl,\n} from '../../../vendor/mongodbUrl';\nimport {\n  parseObjectToMongoObjectForCreate,\n  mongoObjectToParseObject,\n  transformKey,\n  transformWhere,\n  transformUpdate,\n  transformPointerString,\n} from './MongoTransform';\n// @flow-disable-next\nimport Parse                 from 'parse/node';\n// @flow-disable-next\nimport _                     from 'lodash';\nimport defaults              from '../../../defaults';\nimport logger                from '../../../logger';\n\n// @flow-disable-next\nconst mongodb = require('mongodb');\nconst MongoClient = mongodb.MongoClient;\nconst ReadPreference = mongodb.ReadPreference;\n\nconst MongoSchemaCollectionName = '_SCHEMA';\n\nconst storageAdapterAllCollections = mongoAdapter => {\n  return mongoAdapter.connect()\n    .then(() => mongoAdapter.database.collections())\n    .then(collections => {\n      return collections.filter(collection => {\n        if (collection.namespace.match(/\\.system\\./)) {\n          return false;\n        }\n        // TODO: If you have one app with a collection prefix that happens to be a prefix of another\n        // apps prefix, this will go very very badly. We should fix that somehow.\n        return (collection.collectionName.indexOf(mongoAdapter._collectionPrefix) == 0);\n      });\n    });\n}\n\nconst convertParseSchemaToMongoSchema = ({...schema}) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  if (schema.className === '_User') {\n    // Legacy mongo adapter knows about the difference between password and _hashed_password.\n    // Future database adapters will only know about _hashed_password.\n    // Note: Parse Server will bring back password with injectDefaultSchema, so we don't need\n    // to add _hashed_password back ever.\n    delete schema.fields._hashed_password;\n  }\n\n  return schema;\n}\n\n// Returns { code, error } if invalid, or { result }, an object\n// suitable for inserting into _SCHEMA collection, otherwise.\nconst mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPermissions, indexes) => {\n  const mongoObject = {\n    _id: className,\n    objectId: 'string',\n    updatedAt: 'string',\n    createdAt: 'string',\n    _metadata: undefined,\n  };\n\n  for (const fieldName in fields) {\n    mongoObject[fieldName] = MongoSchemaCollection.parseFieldTypeToMongoFieldType(fields[fieldName]);\n  }\n\n  if (typeof classLevelPermissions !== 'undefined') {\n    mongoObject._metadata = mongoObject._metadata || {};\n    if (!classLevelPermissions) {\n      delete mongoObject._metadata.class_permissions;\n    } else {\n      mongoObject._metadata.class_permissions = classLevelPermissions;\n    }\n  }\n\n  if (indexes && typeof indexes === 'object' && Object.keys(indexes).length > 0) {\n    mongoObject._metadata = mongoObject._metadata || {};\n    mongoObject._metadata.indexes = indexes;\n  }\n\n  if (!mongoObject._metadata) { // cleanup the unused _metadata\n    delete mongoObject._metadata;\n  }\n\n  return mongoObject;\n}\n\n\nexport class MongoStorageAdapter implements StorageAdapter {\n  // Private\n  _uri: string;\n  _collectionPrefix: string;\n  _mongoOptions: Object;\n  // Public\n  connectionPromise: Promise<any>;\n  database: any;\n  client: MongoClient;\n  _maxTimeMS: ?number;\n  canSortOnJoinTables: boolean;\n\n  constructor({\n    uri = defaults.DefaultMongoURI,\n    collectionPrefix = '',\n    mongoOptions = {},\n  }: any) {\n    this._uri = uri;\n    this._collectionPrefix = collectionPrefix;\n    this._mongoOptions = mongoOptions;\n    this._mongoOptions.useNewUrlParser = true;\n\n    // MaxTimeMS is not a global MongoDB client option, it is applied per operation.\n    this._maxTimeMS = mongoOptions.maxTimeMS;\n    this.canSortOnJoinTables = true;\n    delete mongoOptions.maxTimeMS;\n  }\n\n  connect() {\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    // parsing and re-formatting causes the auth value (if there) to get URI\n    // encoded\n    const encodedUri = formatUrl(parseUrl(this._uri));\n\n    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(client => {\n      // Starting mongoDB 3.0, the MongoClient.connect don't return a DB anymore but a client\n      // Fortunately, we can get back the options and use them to select the proper DB.\n      // https://github.com/mongodb/node-mongodb-native/blob/2c35d76f08574225b8db02d7bef687123e6bb018/lib/mongo_client.js#L885\n      const options = client.s.options;\n      const database = client.db(options.dbName);\n      if (!database) {\n        delete this.connectionPromise;\n        return;\n      }\n      database.on('error', () => {\n        delete this.connectionPromise;\n      });\n      database.on('close', () => {\n        delete this.connectionPromise;\n      });\n      this.client = client;\n      this.database = database;\n    }).catch((err) => {\n      delete this.connectionPromise;\n      return Promise.reject(err);\n    });\n\n    return this.connectionPromise;\n  }\n\n  handleError<T>(error: ?(Error | Parse.Error)): Promise<T> {\n    if (error && error.code === 13) { // Unauthorized error\n      delete this.client;\n      delete this.database;\n      delete this.connectionPromise;\n      logger.error('Received unauthorized error', { error: error });\n    }\n    throw error;\n  }\n\n  handleShutdown() {\n    if (!this.client) {\n      return;\n    }\n    this.client.close(false);\n  }\n\n  _adaptiveCollection(name: string) {\n    return this.connect()\n      .then(() => this.database.collection(this._collectionPrefix + name))\n      .then(rawCollection => new MongoCollection(rawCollection))\n      .catch(err => this.handleError(err));\n  }\n\n  _schemaCollection(): Promise<MongoSchemaCollection> {\n    return this.connect()\n      .then(() => this._adaptiveCollection(MongoSchemaCollectionName))\n      .then(collection => new MongoSchemaCollection(collection));\n  }\n\n  classExists(name: string) {\n    return this.connect().then(() => {\n      return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();\n    }).then(collections => {\n      return collections.length > 0;\n    }).catch(err => this.handleError(err));\n  }\n\n  setClassLevelPermissions(className: string, CLPs: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.class_permissions': CLPs }\n      })).catch(err => this.handleError(err));\n  }\n\n  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any): Promise<void> {\n    if (submittedIndexes === undefined) {\n      return Promise.resolve();\n    }\n    if (Object.keys(existingIndexes).length === 0) {\n      existingIndexes = { _id_: { _id: 1} };\n    }\n    const deletePromises = [];\n    const insertedIndexes = [];\n    Object.keys(submittedIndexes).forEach(name => {\n      const field = submittedIndexes[name];\n      if (existingIndexes[name] && field.__op !== 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`);\n      }\n      if (!existingIndexes[name] && field.__op === 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`);\n      }\n      if (field.__op === 'Delete') {\n        const promise = this.dropIndex(className, name);\n        deletePromises.push(promise);\n        delete existingIndexes[name];\n      } else {\n        Object.keys(field).forEach(key => {\n          if (!fields.hasOwnProperty(key)) {\n            throw new Parse.Error(Parse.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`);\n          }\n        });\n        existingIndexes[name] = field;\n        insertedIndexes.push({\n          key: field,\n          name,\n        });\n      }\n    });\n    let insertPromise = Promise.resolve();\n    if (insertedIndexes.length > 0) {\n      insertPromise = this.createIndexes(className, insertedIndexes);\n    }\n    return Promise.all(deletePromises)\n      .then(() => insertPromise)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.indexes':  existingIndexes }\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  setIndexesFromMongo(className: string) {\n    return this.getIndexes(className).then((indexes) => {\n      indexes = indexes.reduce((obj, index) => {\n        if (index.key._fts) {\n          delete index.key._fts;\n          delete index.key._ftsx;\n          for (const field in index.weights) {\n            index.key[field] = 'text';\n          }\n        }\n        obj[index.name] = index.key;\n        return obj;\n      }, {});\n      return this._schemaCollection()\n        .then(schemaCollection => schemaCollection.updateSchema(className, {\n          $set: { '_metadata.indexes': indexes }\n        }));\n    })\n      .catch(err => this.handleError(err))\n      .catch(() => {\n        // Ignore if collection not found\n        return Promise.resolve();\n      });\n  }\n\n  createClass(className: string, schema: SchemaType): Promise<void> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions, schema.indexes);\n    mongoObject._id = className;\n    return this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.insertSchema(mongoObject))\n      .catch(err => this.handleError(err));\n  }\n\n  addFieldIfNotExists(className: string, fieldName: string, type: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type))\n      .then(() => this.createIndexesIfNeeded(className, fieldName, type))\n      .catch(err => this.handleError(err));\n  }\n\n  // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)\n  // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.\n  deleteClass(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection.drop())\n      .catch(error => {\n      // 'ns not found' means collection was already gone. Ignore deletion attempt.\n        if (error.message == 'ns not found') {\n          return;\n        }\n        throw error;\n      })\n    // We've dropped the collection, now remove the _SCHEMA document\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.findAndDeleteSchema(className))\n      .catch(err => this.handleError(err));\n  }\n\n  deleteAllClasses(fast: boolean) {\n    return storageAdapterAllCollections(this)\n      .then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop())));\n  }\n\n  // Remove the column and all the data. For Relations, the _Join collection is handled\n  // specially, this function does not delete _Join columns. It should, however, indicate\n  // that the relation fields does not exist anymore. In mongo, this means removing it from\n  // the _SCHEMA collection.  There should be no actual data in the collection under the same name\n  // as the relation column, so it's fine to attempt to delete it. If the fields listed to be\n  // deleted do not exist, this function should return successfully anyways. Checking for\n  // attempts to delete non-existent fields is the responsibility of Parse Server.\n\n  // Pointer field names are passed for legacy reasons: the original mongo\n  // format stored pointer field names differently in the database, and therefore\n  // needed to know the type of the field before it could delete it. Future database\n  // adapters should ignore the pointerFieldNames argument. All the field names are in\n  // fieldNames, they show up additionally in the pointerFieldNames database for use\n  // by the mongo adapter, which deals with the legacy mongo format.\n\n  // This function is not obligated to delete fields atomically. It is given the field\n  // names in a list so that databases that are capable of deleting fields atomically\n  // may do so.\n\n  // Returns a Promise.\n  deleteFields(className: string, schema: SchemaType, fieldNames: string[]) {\n    const mongoFormatNames = fieldNames.map(fieldName => {\n      if (schema.fields[fieldName].type === 'Pointer') {\n        return `_p_${fieldName}`\n      } else {\n        return fieldName;\n      }\n    });\n    const collectionUpdate = { '$unset' : {} };\n    mongoFormatNames.forEach(name => {\n      collectionUpdate['$unset'][name] = null;\n    });\n\n    const schemaUpdate = { '$unset' : {} };\n    fieldNames.forEach(name => {\n      schemaUpdate['$unset'][name] = null;\n    });\n\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany({}, collectionUpdate))\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for all schemas known to this adapter, in Parse format. In case the\n  // schemas cannot be retrieved, returns a promise that rejects. Requirements for the\n  // rejection reason are TBD.\n  getAllClasses(): Promise<StorageClass[]> {\n    return this._schemaCollection().then(schemasCollection => schemasCollection._fetchAllSchemasFrom_SCHEMA())\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for the schema with the given name, in Parse format. If\n  // this adapter doesn't know about the schema, return a promise that rejects with\n  // undefined as the reason.\n  getClass(className: string): Promise<StorageClass> {\n    return this._schemaCollection()\n      .then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className))\n      .catch(err => this.handleError(err));\n  }\n\n  // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema,\n  // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs\n  // the schema only for the legacy mongo format. We'll figure that out later.\n  createObject(className: string, schema: SchemaType, object: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = parseObjectToMongoObjectForCreate(className, object, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.insertOne(mongoObject))\n      .catch(error => {\n        if (error.code === 11000) { // Duplicate value\n          const err = new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          err.underlyingError = error;\n          if (error.message) {\n            const matches = error.message.match(/index:[\\sa-zA-Z0-9_\\-\\.]+\\$?([a-zA-Z_-]+)_1/);\n            if (matches && Array.isArray(matches)) {\n              err.userInfo = { duplicated_field: matches[1] };\n            }\n          }\n          throw err;\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Remove all objects that match the given Parse Query.\n  // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.\n  // If there is some other error, reject with INTERNAL_SERVER_ERROR.\n  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    return this._adaptiveCollection(className)\n      .then(collection => {\n        const mongoWhere = transformWhere(className, query, schema);\n        return collection.deleteMany(mongoWhere)\n      })\n      .catch(err => this.handleError(err))\n      .then(({ result }) => {\n        if (result.n === 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n        return Promise.resolve();\n      }, () => {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error');\n      });\n  }\n\n  // Apply the update to all objects that match the given Parse Query.\n  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Atomically finds and updates an object based on query.\n  // Return value not currently well specified.\n  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.findAndModify(mongoWhere, [], mongoUpdate, { new: true }))\n      .then(result => mongoObjectToParseObject(className, result.value, schema))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Hopefully we can get rid of this. It's only used for config and hooks.\n  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.upsertOne(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.\n  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptions): Promise<any> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));\n    const mongoKeys = _.reduce(keys, (memo, key) => {\n      memo[transformKey(className, key, schema)] = 1;\n      return memo;\n    }, {});\n\n    readPreference = this._parseReadPreference(readPreference);\n    return this.createTextIndexesIfNeeded(className, query, schema)\n      .then(() => this._adaptiveCollection(className))\n      .then(collection => collection.find(mongoWhere, {\n        skip,\n        limit,\n        sort: mongoSort,\n        keys: mongoKeys,\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't\n  // currently know which fields are nullable and which aren't, we ignore that criteria.\n  // As such, we shouldn't expose this function to users of parse until we have an out-of-band\n  // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,\n  // which is why we use sparse indexes.\n  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const indexCreationRequest = {};\n    const mongoFieldNames = fieldNames.map(fieldName => transformKey(className, fieldName, schema));\n    mongoFieldNames.forEach(fieldName => {\n      indexCreationRequest[fieldName] = 1;\n    });\n    return this._adaptiveCollection(className)\n      .then(collection => collection._ensureSparseUniqueIndexInBackground(indexCreationRequest))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Tried to ensure field uniqueness for a class that already has duplicates.');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Used in tests\n  _rawFind(className: string, query: QueryType) {\n    return this._adaptiveCollection(className).then(collection => collection.find(query, {\n      maxTimeMS: this._maxTimeMS,\n    })).catch(err => this.handleError(err));\n  }\n\n  // Executes a count.\n  count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.count(transformWhere(className, query, schema), {\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const isPointerField = schema.fields[fieldName] && schema.fields[fieldName].type === 'Pointer';\n    if (isPointerField) {\n      fieldName = `_p_${fieldName}`\n    }\n    return this._adaptiveCollection(className)\n      .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)))\n      .then(objects => {\n        objects = objects.filter((obj) => obj != null);\n        return objects.map(object => {\n          if (isPointerField) {\n            const field = fieldName.substring(3);\n            return transformPointerString(schema, field, object);\n          }\n          return mongoObjectToParseObject(className, object, schema);\n        });\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) {\n    let isPointerField = false;\n    pipeline = pipeline.map((stage) => {\n      if (stage.$group) {\n        stage.$group = this._parseAggregateGroupArgs(schema, stage.$group);\n        if (stage.$group._id && (typeof stage.$group._id === 'string') && stage.$group._id.indexOf('$_p_') >= 0) {\n          isPointerField = true;\n        }\n      }\n      if (stage.$match) {\n        stage.$match = this._parseAggregateArgs(schema, stage.$match);\n      }\n      if (stage.$project) {\n        stage.$project = this._parseAggregateProjectArgs(schema, stage.$project);\n      }\n      return stage;\n    });\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS }))\n      .catch(error => {\n        if (error.code === 16006) {\n          throw new Parse.Error(Parse.Error.INVALID_QUERY, error.message);\n        }\n        throw error;\n      })\n      .then(results => {\n        results.forEach(result => {\n          if (result.hasOwnProperty('_id')) {\n            if (isPointerField && result._id) {\n              result._id = result._id.split('$')[1];\n            }\n            if (result._id == null || _.isEmpty(result._id)) {\n              result._id = null;\n            }\n            result.objectId = result._id;\n            delete result._id;\n          }\n        });\n        return results;\n      })\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // This function will recursively traverse the pipeline and convert any Pointer or Date columns.\n  // If we detect a pointer column we will rename the column being queried for to match the column\n  // in the database. We also modify the value to what we expect the value to be in the database\n  // as well.\n  // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert\n  // the string to a Date so the driver can perform the necessary comparison.\n  //\n  // The goal of this method is to look for the \"leaves\" of the pipeline and determine if it needs\n  // to be converted. The pipeline can have a few different forms. For more details, see:\n  //     https://docs.mongodb.com/manual/reference/operator/aggregation/\n  //\n  // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In\n  // that case we need to loop through all of it's children to find the columns being operated on.\n  // If the pipeline is an object, then we'll loop through the keys checking to see if the key name\n  // matches one of the schema columns. If it does match a column and the column is a Pointer or\n  // a Date, then we'll convert the value as described above.\n  //\n  // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing\n  // down a tree to find a \"leaf node\" and checking to see if it needs to be converted.\n  _parseAggregateArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n          if (typeof pipeline[field] === 'object') {\n            // Pass objects down to MongoDB...this is more than likely an $exists operator.\n            returnValue[`_p_${field}`] = pipeline[field];\n          } else {\n            returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`;\n          }\n        } else if (schema.fields[field] && schema.fields[field].type === 'Date') {\n          returnValue[field] = this._convertToDate(pipeline[field]);\n        } else {\n          returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n        }\n\n        if (field === 'objectId') {\n          returnValue['_id'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'createdAt') {\n          returnValue['_created_at'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'updatedAt') {\n          returnValue['_updated_at'] = returnValue[field];\n          delete returnValue[field];\n        }\n      }\n      return returnValue;\n    }\n    return pipeline;\n  }\n\n  // This function is slightly different than the one above. Rather than trying to combine these\n  // two functions and making the code even harder to understand, I decided to split it up. The\n  // difference with this function is we are not transforming the values, only the keys of the\n  // pipeline.\n  _parseAggregateProjectArgs(schema: any, pipeline: any): any {\n    const returnValue = {};\n    for (const field in pipeline) {\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        returnValue[`_p_${field}`] = pipeline[field];\n      } else {\n        returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n      }\n\n      if (field === 'objectId') {\n        returnValue['_id'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'createdAt') {\n        returnValue['_created_at'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'updatedAt') {\n        returnValue['_updated_at'] = returnValue[field];\n        delete returnValue[field];\n      }\n    }\n    return returnValue;\n  }\n\n  // This function is slightly different than the two above. MongoDB $group aggregate looks like:\n  //     { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }\n  // The <expression> could be a column name, prefixed with the '$' character. We'll look for\n  // these <expression> and check to see if it is a 'Pointer' or if it's one of createdAt,\n  // updatedAt or objectId and change it accordingly.\n  _parseAggregateGroupArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateGroupArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]);\n      }\n      return returnValue;\n    } else if (typeof pipeline === 'string') {\n      const field = pipeline.substring(1);\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        return `$_p_${field}`;\n      } else if (field == 'createdAt') {\n        return '$_created_at';\n      } else if (field == 'updatedAt') {\n        return '$_updated_at';\n      }\n    }\n    return pipeline;\n  }\n\n  // This function will attempt to convert the provided value to a Date object. Since this is part\n  // of an aggregation pipeline, the value can either be a string or it can be another object with\n  // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a\n  // recursive method to traverse down to the \"leaf node\" which is going to be the string.\n  _convertToDate(value: any): any {\n    if (typeof value === 'string') {\n      return new Date(value);\n    }\n\n    const returnValue = {}\n    for (const field in value) {\n      returnValue[field] = this._convertToDate(value[field])\n    }\n    return returnValue;\n  }\n\n  _parseReadPreference(readPreference: ?string): ?string {\n    switch (readPreference) {\n    case 'PRIMARY':\n      readPreference = ReadPreference.PRIMARY;\n      break;\n    case 'PRIMARY_PREFERRED':\n      readPreference = ReadPreference.PRIMARY_PREFERRED;\n      break;\n    case 'SECONDARY':\n      readPreference = ReadPreference.SECONDARY;\n      break;\n    case 'SECONDARY_PREFERRED':\n      readPreference = ReadPreference.SECONDARY_PREFERRED;\n      break;\n    case 'NEAREST':\n      readPreference = ReadPreference.NEAREST;\n      break;\n    case undefined:\n      break;\n    default:\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');\n    }\n    return readPreference;\n  }\n\n  performInitialization(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  createIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndex(index, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexes(className: string, indexes: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndexes(indexes, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexesIfNeeded(className: string, fieldName: string, type: any) {\n    if (type && type.type === 'Polygon') {\n      const index = {\n        [fieldName]: '2dsphere'\n      };\n      return this.createIndex(className, index);\n    }\n    return Promise.resolve();\n  }\n\n  createTextIndexesIfNeeded(className: string, query: QueryType, schema: any): Promise<void> {\n    for(const fieldName in query) {\n      if (!query[fieldName] || !query[fieldName].$text) {\n        continue;\n      }\n      const existingIndexes = schema.indexes;\n      for (const key in existingIndexes) {\n        const index = existingIndexes[key];\n        if (index.hasOwnProperty(fieldName)) {\n          return Promise.resolve();\n        }\n      }\n      const indexName = `${fieldName}_text`;\n      const textIndex = {\n        [indexName]: { [fieldName]: 'text' }\n      };\n      return this.setIndexesWithSchemaFormat(className, textIndex, existingIndexes, schema.fields)\n        .catch((error) => {\n          if (error.code === 85) { // Index exist with different options\n            return this.setIndexesFromMongo(className);\n          }\n          throw error;\n        });\n    }\n    return Promise.resolve();\n  }\n\n  getIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.indexes())\n      .catch(err => this.handleError(err));\n  }\n\n  dropIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndex(index))\n      .catch(err => this.handleError(err));\n  }\n\n  dropAllIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndexes())\n      .catch(err => this.handleError(err));\n  }\n\n  updateSchemaWithIndexes(): Promise<any> {\n    return this.getAllClasses()\n      .then((classes) => {\n        const promises = classes.map((schema) => {\n          return this.setIndexesFromMongo(schema.className);\n        });\n        return Promise.all(promises);\n      })\n      .catch(err => this.handleError(err));\n  }\n}\n\nexport default MongoStorageAdapter;\n"]} \ No newline at end of file diff --git a/lib/Controllers/PushController.js b/lib/Controllers/PushController.js index 9c783a58fd..1a65f7260d 100644 --- a/lib/Controllers/PushController.js +++ b/lib/Controllers/PushController.js @@ -21,6 +21,8 @@ var _StatusHandler = require('../StatusHandler'); var _utils = require('../Push/utils'); +var _logger = require('../logger'); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } class PushController { @@ -72,6 +74,8 @@ class PushController { badgeUpdate = () => { // Build a real RestQuery so we can use it in RestWrite const restQuery = new _RestQuery2.default(config, (0, _Auth.master)(config), '_Installation', updateWhere); + // change $exists for $ne null for better performance + if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = { $ne: null }; return restQuery.buildRestWhere().then(() => { const write = new _RestWrite2.default(config, (0, _Auth.master)(config), '_Installation', restQuery.restWhere, restUpdate); write.runOptions.many = true; @@ -84,7 +88,15 @@ class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - return badgeUpdate(); + const promise = badgeUpdate(); + // add this to ignore badge update errors as default + if (!config.stopOnBadgeUpdateError) { + promise.catch(err => { + _logger.logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + _logger.logger.error(err); + }); + } + return promise; }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { @@ -212,4 +224,4 @@ class PushController { exports.PushController = PushController; exports.default = PushController; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","buildRestWhere","then","write","RestWrite","restWhere","runOptions","many","execute","pushStatus","setInitial","objectId","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","catch","err","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      return badgeUpdate();\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","promise","stopOnBadgeUpdateError","catch","err","logger","info","error","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      const promise = badgeUpdate();\n      // add this to ignore badge update errors as default\n      if (!config.stopOnBadgeUpdateError) {\n        promise.catch(err => {\n          logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`)\n          logger.error(err)\n        })\n      }\n      return promise\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index ca05b338ff..861010fdf7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1231,25 +1231,25 @@ }, "babel-plugin-syntax-async-functions": { "version": "6.13.0", - "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz", + "resolved": "http://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz", "integrity": "sha1-ytnK0RkbWtY0vzCuCHI5HgZHvpU=", "dev": true }, "babel-plugin-syntax-exponentiation-operator": { "version": "6.13.0", - "resolved": "https://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz", + "resolved": "http://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz", "integrity": "sha1-nufoM3KQ2pUoggGmpX9BcDF4MN4=", "dev": true }, "babel-plugin-syntax-flow": { "version": "6.18.0", - "resolved": "https://registry.npmjs.org/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz", + "resolved": "http://registry.npmjs.org/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz", "integrity": "sha1-TDqyCiryaqIM0lmVw5jE63AxDI0=", "dev": true }, "babel-plugin-syntax-object-rest-spread": { "version": "6.13.0", - "resolved": "https://registry.npmjs.org/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz", + "resolved": "http://registry.npmjs.org/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz", "integrity": "sha1-/WU28rzhODb/o6VFjEkDpZe7O/U=", "dev": true }, @@ -5531,7 +5531,7 @@ "http-proxy-agent": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-2.1.0.tgz", - "integrity": "sha1-5IIb7vWyFCogJr1zkm/lN2McVAU=", + "integrity": "sha512-qwHbBLV7WviBl0rQsOzH6o5lwyOIvwp/BdFnvVxXORldu5TmjFfjzBcWUWS5kWAZhmv+JtiDhSuQCp4sBfbIgg==", "requires": { "agent-base": "4.2.0", "debug": "3.1.0" @@ -5550,7 +5550,7 @@ "https-proxy-agent": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.1.tgz", - "integrity": "sha1-UVUpcPoE1yPgTFbQQXjD+SWSu8A=", + "integrity": "sha512-HPCTS1LW51bcyMYbxUIOO4HEOlQ1/1qRaFWcyxvwaqUS9TY88aoEuHUY33kuAh1YhVVaDQhLZsnPd+XNARWZlQ==", "requires": { "agent-base": "4.2.0", "debug": "3.1.0" @@ -6709,7 +6709,7 @@ "mailgun-js": { "version": "0.18.0", "resolved": "https://registry.npmjs.org/mailgun-js/-/mailgun-js-0.18.0.tgz", - "integrity": "sha1-gf7QxmpBHT/2xDVIYa0hOHr8+qo=", + "integrity": "sha512-o0P6jjZlx5CQj12tvVgDTbgjTqVN0+5h6/6P1+3c6xmozVKBwniQ6Qt3MkCSF0+ueVTbobAfWyGpWRZMJu8t1g==", "requires": { "async": "2.6.0", "debug": "3.1.0", From 450192ca0ac7c9fe2b43838ff43b79ab21496596 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 26 Sep 2018 13:03:56 -0300 Subject: [PATCH 08/73] Fix ignore badge update error --- src/Controllers/PushController.js | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index f58fb67ad6..77829d216e 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -73,15 +73,12 @@ export class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - const promise = badgeUpdate(); + return badgeUpdate(); + }).catch(err => { // add this to ignore badge update errors as default - if (!config.stopOnBadgeUpdateError) { - promise.catch(err => { - logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`) - logger.error(err) - }) - } - return promise + if (config.stopOnBadgeUpdateError) throw err + logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`) + logger.error(err) }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { From 805e468d5a4f24b668c47d574aaa453898a75a34 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Thu, 27 Sep 2018 09:30:41 -0300 Subject: [PATCH 09/73] Fix ignore badge update error --- src/Controllers/PushController.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index 77829d216e..ee5242cb1e 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -78,7 +78,8 @@ export class PushController { // add this to ignore badge update errors as default if (config.stopOnBadgeUpdateError) throw err logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`) - logger.error(err) + logger.info(err && err.stack && err.stack.toString() || err.toString()) + return Promise.resolve() }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { From bf63d1b7f9dc80d64dd27539c5cc860d8ff31498 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Thu, 27 Sep 2018 10:34:58 -0300 Subject: [PATCH 10/73] Fix ignore badge update error --- src/Controllers/PushController.js | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index ee5242cb1e..dff15322be 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -73,13 +73,9 @@ export class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - return badgeUpdate(); - }).catch(err => { - // add this to ignore badge update errors as default - if (config.stopOnBadgeUpdateError) throw err - logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`) - logger.info(err && err.stack && err.stack.toString() || err.toString()) - return Promise.resolve() + if (config.stopOnBadgeUpdateError) return badgeUpdate(); + logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + return Promise.resolve(); }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { From 2dc05c1ef25e1533082c0fbb7c8682209895361c Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Thu, 27 Sep 2018 10:35:15 -0300 Subject: [PATCH 11/73] Fix ignore badge update error --- lib/Controllers/PushController.js | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/lib/Controllers/PushController.js b/lib/Controllers/PushController.js index 1a65f7260d..40d6340998 100644 --- a/lib/Controllers/PushController.js +++ b/lib/Controllers/PushController.js @@ -88,15 +88,9 @@ class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - const promise = badgeUpdate(); - // add this to ignore badge update errors as default - if (!config.stopOnBadgeUpdateError) { - promise.catch(err => { - _logger.logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); - _logger.logger.error(err); - }); - } - return promise; + if (config.stopOnBadgeUpdateError) return badgeUpdate(); + _logger.logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + return Promise.resolve(); }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { @@ -224,4 +218,4 @@ class PushController { exports.PushController = PushController; exports.default = PushController; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","promise","stopOnBadgeUpdateError","catch","err","logger","info","error","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      const promise = badgeUpdate();\n      // add this to ignore badge update errors as default\n      if (!config.stopOnBadgeUpdateError) {\n        promise.catch(err => {\n          logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`)\n          logger.error(err)\n        })\n      }\n      return promise\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","stopOnBadgeUpdateError","logger","info","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","catch","err","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      if (config.stopOnBadgeUpdateError) return badgeUpdate();\n      logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`);\n      return Promise.resolve();\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file From 037329f63bf826831846d287a8a888a9f8b1a057 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Thu, 27 Sep 2018 12:10:34 -0300 Subject: [PATCH 12/73] Fix ignore badge update error --- lib/Controllers/PushController.js | 8 ++++++-- src/Controllers/PushController.js | 6 +++++- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/lib/Controllers/PushController.js b/lib/Controllers/PushController.js index 40d6340998..6432bc8ed1 100644 --- a/lib/Controllers/PushController.js +++ b/lib/Controllers/PushController.js @@ -88,8 +88,12 @@ class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - if (config.stopOnBadgeUpdateError) return badgeUpdate(); + return badgeUpdate(); + }).catch(err => { + // add this to ignore badge update errors as default + if (config.stopOnBadgeUpdateError) throw err; _logger.logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + _logger.logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString()); return Promise.resolve(); }).then(() => { // Update audience lastUsed and timesUsed @@ -218,4 +222,4 @@ class PushController { exports.PushController = PushController; exports.default = PushController; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","stopOnBadgeUpdateError","logger","info","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","catch","err","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      if (config.stopOnBadgeUpdateError) return badgeUpdate();\n      logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`);\n      return Promise.resolve();\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","catch","err","stopOnBadgeUpdateError","logger","info","stack","toString","message","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      return badgeUpdate();\n    }).catch(err => {\n      // add this to ignore badge update errors as default\n      if (config.stopOnBadgeUpdateError) throw err;\n      logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`);\n      logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString());\n      return Promise.resolve();\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index dff15322be..b374ec721f 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -73,8 +73,12 @@ export class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - if (config.stopOnBadgeUpdateError) return badgeUpdate(); + return badgeUpdate(); + }).catch(err => { + // add this to ignore badge update errors as default + if (config.stopOnBadgeUpdateError) throw err; logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString()); return Promise.resolve(); }).then(() => { // Update audience lastUsed and timesUsed From f387c9eb47fc9479e4d945b114ea36d6579556fc Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Thu, 27 Sep 2018 12:11:28 -0300 Subject: [PATCH 13/73] Fix ignore badge update error --- lib/Controllers/PushController.js | 16 ++++++++-------- src/Controllers/PushController.js | 14 +++++++------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/lib/Controllers/PushController.js b/lib/Controllers/PushController.js index 6432bc8ed1..6f1f16cd80 100644 --- a/lib/Controllers/PushController.js +++ b/lib/Controllers/PushController.js @@ -88,13 +88,13 @@ class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - return badgeUpdate(); - }).catch(err => { - // add this to ignore badge update errors as default - if (config.stopOnBadgeUpdateError) throw err; - _logger.logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); - _logger.logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString()); - return Promise.resolve(); + return badgeUpdate().catch(err => { + // add this to ignore badge update errors as default + if (config.stopOnBadgeUpdateError) throw err; + _logger.logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + _logger.logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString()); + return Promise.resolve(); + }); }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { @@ -222,4 +222,4 @@ class PushController { exports.PushController = PushController; exports.default = PushController; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","catch","err","stopOnBadgeUpdateError","logger","info","stack","toString","message","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":"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","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      return badgeUpdate();\n    }).catch(err => {\n      // add this to ignore badge update errors as default\n      if (config.stopOnBadgeUpdateError) throw err;\n      logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`);\n      logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString());\n      return Promise.resolve();\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Controllers/PushController.js"],"names":["PushController","sendPush","body","where","config","auth","onPushStatusSaved","now","Date","hasPushSupport","Parse","Error","PUSH_MISCONFIGURED","expiration_time","getExpirationTime","expiration_interval","getExpirationInterval","hasOwnProperty","ttlMs","valueOf","pushTime","getPushTime","date","formatPushTime","badgeUpdate","Promise","resolve","data","badge","restUpdate","toLowerCase","__op","amount","Number","updateWhere","restQuery","RestQuery","restWhere","deviceToken","$ne","buildRestWhere","then","write","RestWrite","runOptions","many","execute","pushStatus","setInitial","objectId","catch","err","stopOnBadgeUpdateError","logger","info","stack","toString","message","audience_id","audienceId","updateAudience","lastUsed","__type","iso","toISOString","timesUsed","hasPushScheduledSupport","pushControllerQueue","enqueue","fail","hasExpirationTime","expirationTimeParam","expirationTime","isFinite","hasExpirationInterval","expirationIntervalParam","hasPushTime","pushTimeParam","isLocalTime","pushTimeHasTimezoneComponent","offsetPattern","indexOf","length","test","isoString","substring"],"mappings":";;;;;;;AAAA;;AACA;;;;AACA;;;;AACA;;AACA;;AACA;;AACA;;;;AAEO,MAAMA,cAAN,CAAqB;;AAE1BC,WAASC,OAAO,EAAhB,EAAoBC,QAAQ,EAA5B,EAAgCC,MAAhC,EAAwCC,IAAxC,EAA8CC,oBAAoB,MAAM,CAAE,CAA1E,EAA4EC,MAAM,IAAIC,IAAJ,EAAlF,EAA8F;AAC5F,QAAI,CAACJ,OAAOK,cAAZ,EAA4B;AAC1B,YAAM,IAAIC,YAAMC,KAAV,CAAgBD,YAAMC,KAAN,CAAYC,kBAA5B,EACJ,4BADI,CAAN;AAED;;AAED;AACAV,SAAKW,eAAL,GAAuBb,eAAec,iBAAf,CAAiCZ,IAAjC,CAAvB;AACAA,SAAKa,mBAAL,GAA2Bf,eAAegB,qBAAf,CAAqCd,IAArC,CAA3B;AACA,QAAIA,KAAKW,eAAL,IAAwBX,KAAKa,mBAAjC,EAAsD;AACpD,YAAM,IAAIL,YAAMC,KAAV,CACJD,YAAMC,KAAN,CAAYC,kBADR,EAEJ,4DAFI,CAAN;AAGD;;AAED;AACA,QAAIV,KAAKa,mBAAL,IAA4B,CAACb,KAAKe,cAAL,CAAoB,WAApB,CAAjC,EAAmE;AACjE,YAAMC,QAAQhB,KAAKa,mBAAL,GAA2B,IAAzC;AACAb,WAAKW,eAAL,GAAwB,IAAIL,IAAJ,CAASD,IAAIY,OAAJ,KAAgBD,KAAzB,CAAD,CAAkCC,OAAlC,EAAvB;AACD;;AAED,UAAMC,WAAWpB,eAAeqB,WAAf,CAA2BnB,IAA3B,CAAjB;AACA,QAAIkB,YAAYA,SAASE,IAAT,KAAkB,WAAlC,EAA+C;AAC7CpB,WAAK,WAAL,IAAoBF,eAAeuB,cAAf,CAA8BH,QAA9B,CAApB;AACD;;AAED;AACA;AACA,QAAII,cAAc,MAAM;AACtB,aAAOC,QAAQC,OAAR,EAAP;AACD,KAFD;;AAIA,QAAIxB,KAAKyB,IAAL,IAAazB,KAAKyB,IAAL,CAAUC,KAA3B,EAAkC;AAChC,YAAMA,QAAQ1B,KAAKyB,IAAL,CAAUC,KAAxB;AACA,UAAIC,aAAa,EAAjB;AACA,UAAI,OAAOD,KAAP,IAAgB,QAAhB,IAA4BA,MAAME,WAAN,OAAwB,WAAxD,EAAqE;AACnED,qBAAa,EAAED,OAAO,EAAEG,MAAM,WAAR,EAAqBC,QAAQ,CAA7B,EAAT,EAAb;AACD,OAFD,MAEO,IAAI,OAAOJ,KAAP,IAAgB,QAAhB,IAA4B,OAAOA,MAAMG,IAAb,IAAqB,QAAjD,IACAH,MAAMG,IAAN,CAAWD,WAAX,MAA4B,WAD5B,IAC2CG,OAAOL,MAAMI,MAAb,CAD/C,EACqE;AAC1EH,qBAAa,EAAED,OAAO,EAAEG,MAAM,WAAR,EAAqBC,QAAQJ,MAAMI,MAAnC,EAAT,EAAb;AACD,OAHM,MAGA,IAAIC,OAAOL,KAAP,CAAJ,EAAmB;AACxBC,qBAAa,EAAED,OAAOA,KAAT,EAAb;AACD,OAFM,MAEA;AACL,cAAM,gFAAN;AACD;;AAED;AACA,YAAMM,cAAc,mCAAuB/B,KAAvB,CAApB;AACAqB,oBAAc,MAAM;AAClB;AACA,cAAMW,YAAY,IAAIC,mBAAJ,CAAchC,MAAd,EAAsB,kBAAOA,MAAP,CAAtB,EAAsC,eAAtC,EAAuD8B,WAAvD,CAAlB;AACA;AACA,YAAIC,UAAUE,SAAV,IAAuBF,UAAUE,SAAV,CAAoBC,WAA3C,IAA0DH,UAAUE,SAAV,CAAoBC,WAApB,CAAgC,SAAhC,CAA9D,EAA0GH,UAAUE,SAAV,CAAoBC,WAApB,GAAkC,EAACC,KAAK,IAAN,EAAlC;AAC1G,eAAOJ,UAAUK,cAAV,GAA2BC,IAA3B,CAAgC,MAAM;AAC3C,gBAAMC,QAAQ,IAAIC,mBAAJ,CAAcvC,MAAd,EAAsB,kBAAOA,MAAP,CAAtB,EAAsC,eAAtC,EAAuD+B,UAAUE,SAAjE,EAA4ER,UAA5E,CAAd;AACAa,gBAAME,UAAN,CAAiBC,IAAjB,GAAwB,IAAxB;AACA,iBAAOH,MAAMI,OAAN,EAAP;AACD,SAJM,CAAP;AAKD,OAVD;AAWD;AACD,UAAMC,aAAa,sCAAkB3C,MAAlB,CAAnB;AACA,WAAOqB,QAAQC,OAAR,GAAkBe,IAAlB,CAAuB,MAAM;AAClC,aAAOM,WAAWC,UAAX,CAAsB9C,IAAtB,EAA4BC,KAA5B,CAAP;AACD,KAFM,EAEJsC,IAFI,CAEC,MAAM;AACZnC,wBAAkByC,WAAWE,QAA7B;AACA,aAAOzB,cAAc0B,KAAd,CAAoBC,OAAO;AAChC;AACA,YAAI/C,OAAOgD,sBAAX,EAAmC,MAAMD,GAAN;AACnCE,uBAAOC,IAAP,CAAa,sDAAqDP,WAAWE,QAAS,EAAtF;AACAI,uBAAOC,IAAP,CAAYH,OAAOA,IAAII,KAAX,IAAoBJ,IAAII,KAAJ,CAAUC,QAAV,EAApB,IAA4CL,OAAOA,IAAIM,OAAvD,IAAkEN,IAAIK,QAAJ,EAA9E;AACA,eAAO/B,QAAQC,OAAR,EAAP;AACD,OANM,CAAP;AAOD,KAXM,EAWJe,IAXI,CAWC,MAAM;AACZ;AACA,UAAIvC,KAAKwD,WAAT,EAAsB;AACpB,cAAMC,aAAazD,KAAKwD,WAAxB;;AAEA,YAAIE,iBAAiB;AACnBC,oBAAU,EAAEC,QAAQ,MAAV,EAAkBC,KAAK,IAAIvD,IAAJ,GAAWwD,WAAX,EAAvB,EADS;AAEnBC,qBAAW,EAAElC,MAAM,WAAR,EAAqB,UAAU,CAA/B;AAFQ,SAArB;AAIA,cAAMW,QAAQ,IAAIC,mBAAJ,CAAcvC,MAAd,EAAsB,kBAAOA,MAAP,CAAtB,EAAsC,WAAtC,EAAmD,EAAC6C,UAAUU,UAAX,EAAnD,EAA2EC,cAA3E,CAAd;AACAlB,cAAMI,OAAN;AACD;AACD;AACA,aAAOrB,QAAQC,OAAR,EAAP;AACD,KAzBM,EAyBJe,IAzBI,CAyBC,MAAM;AACZ,UAAIvC,KAAKe,cAAL,CAAoB,WAApB,KAAoCb,OAAO8D,uBAA/C,EAAwE;AACtE,eAAOzC,QAAQC,OAAR,EAAP;AACD;AACD,aAAOtB,OAAO+D,mBAAP,CAA2BC,OAA3B,CAAmClE,IAAnC,EAAyCC,KAAzC,EAAgDC,MAAhD,EAAwDC,IAAxD,EAA8D0C,UAA9D,CAAP;AACD,KA9BM,EA8BJG,KA9BI,CA8BGC,GAAD,IAAS;AAChB,aAAOJ,WAAWsB,IAAX,CAAgBlB,GAAhB,EAAqBV,IAArB,CAA0B,MAAM;AACrC,cAAMU,GAAN;AACD,OAFM,CAAP;AAGD,KAlCM,CAAP;AAmCD;;AAED;;;;;AAKA,SAAOrC,iBAAP,CAAyBZ,OAAO,EAAhC,EAAoC;AAClC,QAAIoE,oBAAoBpE,KAAKe,cAAL,CAAoB,iBAApB,CAAxB;AACA,QAAI,CAACqD,iBAAL,EAAwB;AACtB;AACD;AACD,QAAIC,sBAAsBrE,KAAK,iBAAL,CAA1B;AACA,QAAIsE,cAAJ;AACA,QAAI,OAAOD,mBAAP,KAA+B,QAAnC,EAA6C;AAC3CC,uBAAiB,IAAIhE,IAAJ,CAAS+D,sBAAsB,IAA/B,CAAjB;AACD,KAFD,MAEO,IAAI,OAAOA,mBAAP,KAA+B,QAAnC,EAA6C;AAClDC,uBAAiB,IAAIhE,IAAJ,CAAS+D,mBAAT,CAAjB;AACD,KAFM,MAEA;AACL,YAAM,IAAI7D,YAAMC,KAAV,CAAgBD,YAAMC,KAAN,CAAYC,kBAA5B,EACJV,KAAK,iBAAL,IAA0B,qBADtB,CAAN;AAED;AACD;AACA,QAAI,CAACuE,SAASD,cAAT,CAAL,EAA+B;AAC7B,YAAM,IAAI9D,YAAMC,KAAV,CAAgBD,YAAMC,KAAN,CAAYC,kBAA5B,EACJV,KAAK,iBAAL,IAA0B,qBADtB,CAAN;AAED;AACD,WAAOsE,eAAerD,OAAf,EAAP;AACD;;AAED,SAAOH,qBAAP,CAA6Bd,OAAO,EAApC,EAAwC;AACtC,UAAMwE,wBAAwBxE,KAAKe,cAAL,CAAoB,qBAApB,CAA9B;AACA,QAAI,CAACyD,qBAAL,EAA4B;AAC1B;AACD;;AAED,QAAIC,0BAA0BzE,KAAK,qBAAL,CAA9B;AACA,QAAI,OAAOyE,uBAAP,KAAmC,QAAnC,IAA+CA,2BAA2B,CAA9E,EAAiF;AAC/E,YAAM,IAAIjE,YAAMC,KAAV,CAAgBD,YAAMC,KAAN,CAAYC,kBAA5B,EACH,qDADG,CAAN;AAED;AACD,WAAO+D,uBAAP;AACD;;AAED;;;;;AAKA,SAAOtD,WAAP,CAAmBnB,OAAO,EAA1B,EAA8B;AAC5B,QAAI0E,cAAc1E,KAAKe,cAAL,CAAoB,WAApB,CAAlB;AACA,QAAI,CAAC2D,WAAL,EAAkB;AAChB;AACD;AACD,QAAIC,gBAAgB3E,KAAK,WAAL,CAApB;AACA,QAAIoB,IAAJ;AACA,QAAIwD,cAAc,IAAlB;;AAEA,QAAI,OAAOD,aAAP,KAAyB,QAA7B,EAAuC;AACrCvD,aAAO,IAAId,IAAJ,CAASqE,gBAAgB,IAAzB,CAAP;AACD,KAFD,MAEO,IAAI,OAAOA,aAAP,KAAyB,QAA7B,EAAuC;AAC5CC,oBAAc,CAAC9E,eAAe+E,4BAAf,CAA4CF,aAA5C,CAAf;AACAvD,aAAO,IAAId,IAAJ,CAASqE,aAAT,CAAP;AACD,KAHM,MAGA;AACL,YAAM,IAAInE,YAAMC,KAAV,CAAgBD,YAAMC,KAAN,CAAYC,kBAA5B,EACJV,KAAK,WAAL,IAAoB,qBADhB,CAAN;AAED;AACD;AACA,QAAI,CAACuE,SAASnD,IAAT,CAAL,EAAqB;AACnB,YAAM,IAAIZ,YAAMC,KAAV,CAAgBD,YAAMC,KAAN,CAAYC,kBAA5B,EACJV,KAAK,WAAL,IAAoB,qBADhB,CAAN;AAED;;AAED,WAAO;AACLoB,UADK;AAELwD;AAFK,KAAP;AAID;;AAED;;;;;AAKA,SAAOC,4BAAP,CAAoCF,aAApC,EAAoE;AAClE,UAAMG,gBAAgB,sBAAtB;AACA,WAAOH,cAAcI,OAAd,CAAsB,GAAtB,MAA+BJ,cAAcK,MAAd,GAAuB,CAAtD,CAAwD;AAAxD,OACFF,cAAcG,IAAd,CAAmBN,aAAnB,CADL,CAFkE,CAG1B;AACzC;;AAED;;;;;;AAMA,SAAOtD,cAAP,CAAsB,EAAED,IAAF,EAAQwD,WAAR,EAAtB,EAAmF;AACjF,QAAIA,WAAJ,EAAiB;AAAE;AACjB,YAAMM,YAAY9D,KAAK0C,WAAL,EAAlB;AACA,aAAOoB,UAAUC,SAAV,CAAoB,CAApB,EAAuBD,UAAUH,OAAV,CAAkB,GAAlB,CAAvB,CAAP;AACD;AACD,WAAO3D,KAAK0C,WAAL,EAAP;AACD;AAxMyB;;QAAfhE,c,GAAAA,c;kBA2MEA,c","file":"PushController.js","sourcesContent":["import { Parse }              from 'parse/node';\nimport RestQuery              from '../RestQuery';\nimport RestWrite              from '../RestWrite';\nimport { master }             from '../Auth';\nimport { pushStatusHandler }  from '../StatusHandler';\nimport { applyDeviceTokenExists } from '../Push/utils';\nimport { logger }               from '../logger';\n\nexport class PushController {\n\n  sendPush(body = {}, where = {}, config, auth, onPushStatusSaved = () => {}, now = new Date()) {\n    if (!config.hasPushSupport) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        'Missing push configuration');\n    }\n\n    // Replace the expiration_time and push_time with a valid Unix epoch milliseconds time\n    body.expiration_time = PushController.getExpirationTime(body);\n    body.expiration_interval = PushController.getExpirationInterval(body);\n    if (body.expiration_time && body.expiration_interval) {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Both expiration_time and expiration_interval cannot be set');\n    }\n\n    // Immediate push\n    if (body.expiration_interval && !body.hasOwnProperty('push_time')) {\n      const ttlMs = body.expiration_interval * 1000;\n      body.expiration_time = (new Date(now.valueOf() + ttlMs)).valueOf();\n    }\n\n    const pushTime = PushController.getPushTime(body);\n    if (pushTime && pushTime.date !== 'undefined') {\n      body['push_time'] = PushController.formatPushTime(pushTime);\n    }\n\n    // TODO: If the req can pass the checking, we return immediately instead of waiting\n    // pushes to be sent. We probably change this behaviour in the future.\n    let badgeUpdate = () => {\n      return Promise.resolve();\n    }\n\n    if (body.data && body.data.badge) {\n      const badge = body.data.badge;\n      let restUpdate = {};\n      if (typeof badge == 'string' && badge.toLowerCase() === 'increment') {\n        restUpdate = { badge: { __op: 'Increment', amount: 1 } }\n      } else if (typeof badge == 'object' && typeof badge.__op == 'string' &&\n                 badge.__op.toLowerCase() == 'increment' && Number(badge.amount)) {\n        restUpdate = { badge: { __op: 'Increment', amount: badge.amount } }\n      } else if (Number(badge)) {\n        restUpdate = { badge: badge }\n      } else {\n        throw \"Invalid value for badge, expected number or 'Increment' or {increment: number}\";\n      }\n\n      // Force filtering on only valid device tokens\n      const updateWhere = applyDeviceTokenExists(where);\n      badgeUpdate = () => {\n        // Build a real RestQuery so we can use it in RestWrite\n        const restQuery = new RestQuery(config, master(config), '_Installation', updateWhere);\n        // change $exists for $ne null for better performance\n        if (restQuery.restWhere && restQuery.restWhere.deviceToken && restQuery.restWhere.deviceToken['$exists']) restQuery.restWhere.deviceToken = {$ne: null}\n        return restQuery.buildRestWhere().then(() => {\n          const write = new RestWrite(config, master(config), '_Installation', restQuery.restWhere, restUpdate);\n          write.runOptions.many = true;\n          return write.execute();\n        });\n      }\n    }\n    const pushStatus = pushStatusHandler(config);\n    return Promise.resolve().then(() => {\n      return pushStatus.setInitial(body, where);\n    }).then(() => {\n      onPushStatusSaved(pushStatus.objectId);\n      return badgeUpdate().catch(err => {\n        // add this to ignore badge update errors as default\n        if (config.stopOnBadgeUpdateError) throw err;\n        logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`);\n        logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString());\n        return Promise.resolve();\n      });\n    }).then(() => {\n      // Update audience lastUsed and timesUsed\n      if (body.audience_id) {\n        const audienceId = body.audience_id;\n\n        var updateAudience = {\n          lastUsed: { __type: \"Date\", iso: new Date().toISOString() },\n          timesUsed: { __op: \"Increment\", \"amount\": 1 }\n        };\n        const write = new RestWrite(config, master(config), '_Audience', {objectId: audienceId}, updateAudience);\n        write.execute();\n      }\n      // Don't wait for the audience update promise to resolve.\n      return Promise.resolve();\n    }).then(() => {\n      if (body.hasOwnProperty('push_time') && config.hasPushScheduledSupport) {\n        return Promise.resolve();\n      }\n      return config.pushControllerQueue.enqueue(body, where, config, auth, pushStatus);\n    }).catch((err) => {\n      return pushStatus.fail(err).then(() => {\n        throw err;\n      });\n    });\n  }\n\n  /**\n   * Get expiration time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The expiration time if it exists in the request\n   */\n  static getExpirationTime(body = {}) {\n    var hasExpirationTime = body.hasOwnProperty('expiration_time');\n    if (!hasExpirationTime) {\n      return;\n    }\n    var expirationTimeParam = body['expiration_time'];\n    var expirationTime;\n    if (typeof expirationTimeParam === 'number') {\n      expirationTime = new Date(expirationTimeParam * 1000);\n    } else if (typeof expirationTimeParam === 'string') {\n      expirationTime = new Date(expirationTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    // Check expirationTime is valid or not, if it is not valid, expirationTime is NaN\n    if (!isFinite(expirationTime)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['expiration_time'] + ' is not valid time.');\n    }\n    return expirationTime.valueOf();\n  }\n\n  static getExpirationInterval(body = {}) {\n    const hasExpirationInterval = body.hasOwnProperty('expiration_interval');\n    if (!hasExpirationInterval) {\n      return;\n    }\n\n    var expirationIntervalParam = body['expiration_interval'];\n    if (typeof expirationIntervalParam !== 'number' || expirationIntervalParam <= 0) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        `expiration_interval must be a number greater than 0`);\n    }\n    return expirationIntervalParam;\n  }\n\n  /**\n   * Get push time from the request body.\n   * @param {Object} request A request object\n   * @returns {Number|undefined} The push time if it exists in the request\n   */\n  static getPushTime(body = {}) {\n    var hasPushTime = body.hasOwnProperty('push_time');\n    if (!hasPushTime) {\n      return;\n    }\n    var pushTimeParam = body['push_time'];\n    var date;\n    var isLocalTime = true;\n\n    if (typeof pushTimeParam === 'number') {\n      date = new Date(pushTimeParam * 1000);\n    } else if (typeof pushTimeParam === 'string') {\n      isLocalTime = !PushController.pushTimeHasTimezoneComponent(pushTimeParam);\n      date = new Date(pushTimeParam);\n    } else {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n    // Check pushTime is valid or not, if it is not valid, pushTime is NaN\n    if (!isFinite(date)) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,\n        body['push_time'] + ' is not valid time.');\n    }\n\n    return {\n      date,\n      isLocalTime,\n    };\n  }\n\n  /**\n   * Checks if a ISO8601 formatted date contains a timezone component\n   * @param pushTimeParam {string}\n   * @returns {boolean}\n   */\n  static pushTimeHasTimezoneComponent(pushTimeParam: string): boolean {\n    const offsetPattern = /(.+)([+-])\\d\\d:\\d\\d$/;\n    return pushTimeParam.indexOf('Z') === pushTimeParam.length - 1 // 2007-04-05T12:30Z\n      || offsetPattern.test(pushTimeParam); // 2007-04-05T12:30.000+02:00, 2007-04-05T12:30.000-02:00\n  }\n\n  /**\n   * Converts a date to ISO format in UTC time and strips the timezone if `isLocalTime` is true\n   * @param date {Date}\n   * @param isLocalTime {boolean}\n   * @returns {string}\n   */\n  static formatPushTime({ date, isLocalTime }: { date: Date, isLocalTime: boolean }) {\n    if (isLocalTime) { // Strip 'Z'\n      const isoString = date.toISOString();\n      return isoString.substring(0, isoString.indexOf('Z'));\n    }\n    return date.toISOString();\n  }\n}\n\nexport default PushController;\n"]} \ No newline at end of file diff --git a/src/Controllers/PushController.js b/src/Controllers/PushController.js index b374ec721f..e0ede9d906 100644 --- a/src/Controllers/PushController.js +++ b/src/Controllers/PushController.js @@ -73,13 +73,13 @@ export class PushController { return pushStatus.setInitial(body, where); }).then(() => { onPushStatusSaved(pushStatus.objectId); - return badgeUpdate(); - }).catch(err => { - // add this to ignore badge update errors as default - if (config.stopOnBadgeUpdateError) throw err; - logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); - logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString()); - return Promise.resolve(); + return badgeUpdate().catch(err => { + // add this to ignore badge update errors as default + if (config.stopOnBadgeUpdateError) throw err; + logger.info(`Badge update error will be ignored for push status ${pushStatus.objectId}`); + logger.info(err && err.stack && err.stack.toString() || err && err.message || err.toString()); + return Promise.resolve(); + }); }).then(() => { // Update audience lastUsed and timesUsed if (body.audience_id) { From c505d7b0162524953233dc3129a45ebf94594670 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Tue, 16 Oct 2018 16:48:44 -0300 Subject: [PATCH 14/73] Build --- lib/Adapters/Storage/Mongo/MongoStorageAdapter.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js index dbd8421b3c..a1a20c35c1 100644 --- a/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js +++ b/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js @@ -127,6 +127,7 @@ class MongoStorageAdapter { this._uri = uri; this._collectionPrefix = collectionPrefix; this._mongoOptions = mongoOptions; + this._mongoOptions.useNewUrlParser = true; // MaxTimeMS is not a global MongoDB client option, it is applied per operation. this._maxTimeMS = mongoOptions.maxTimeMS; @@ -769,4 +770,4 @@ class MongoStorageAdapter { exports.MongoStorageAdapter = MongoStorageAdapter; exports.default = MongoStorageAdapter; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoStorageAdapter.js"],"names":["mongodb","require","MongoClient","ReadPreference","MongoSchemaCollectionName","storageAdapterAllCollections","mongoAdapter","connect","then","database","collections","filter","collection","namespace","match","collectionName","indexOf","_collectionPrefix","convertParseSchemaToMongoSchema","schema","fields","_rperm","_wperm","className","_hashed_password","mongoSchemaFromFieldsAndClassNameAndCLP","classLevelPermissions","indexes","mongoObject","_id","objectId","updatedAt","createdAt","_metadata","undefined","fieldName","MongoSchemaCollection","parseFieldTypeToMongoFieldType","class_permissions","Object","keys","length","MongoStorageAdapter","constructor","uri","defaults","DefaultMongoURI","collectionPrefix","mongoOptions","_uri","_mongoOptions","_maxTimeMS","maxTimeMS","canSortOnJoinTables","connectionPromise","encodedUri","client","options","s","db","dbName","on","catch","err","Promise","reject","handleError","error","code","logger","handleShutdown","close","_adaptiveCollection","name","rawCollection","MongoCollection","_schemaCollection","classExists","listCollections","toArray","setClassLevelPermissions","CLPs","schemaCollection","updateSchema","$set","setIndexesWithSchemaFormat","submittedIndexes","existingIndexes","resolve","_id_","deletePromises","insertedIndexes","forEach","field","__op","Parse","Error","INVALID_QUERY","promise","dropIndex","push","key","hasOwnProperty","insertPromise","createIndexes","all","setIndexesFromMongo","getIndexes","reduce","obj","index","_fts","_ftsx","weights","createClass","insertSchema","addFieldIfNotExists","type","createIndexesIfNeeded","deleteClass","drop","message","findAndDeleteSchema","deleteAllClasses","fast","map","remove","deleteFields","fieldNames","mongoFormatNames","collectionUpdate","schemaUpdate","updateMany","getAllClasses","schemasCollection","_fetchAllSchemasFrom_SCHEMA","getClass","_fetchOneSchemaFrom_SCHEMA","createObject","object","insertOne","DUPLICATE_VALUE","underlyingError","matches","Array","isArray","userInfo","duplicated_field","deleteObjectsByQuery","query","mongoWhere","deleteMany","result","n","OBJECT_NOT_FOUND","INTERNAL_SERVER_ERROR","updateObjectsByQuery","update","mongoUpdate","findOneAndUpdate","_mongoCollection","findAndModify","new","value","upsertOneObject","upsertOne","find","skip","limit","sort","readPreference","mongoSort","_","mapKeys","mongoKeys","memo","_parseReadPreference","createTextIndexesIfNeeded","objects","ensureUniqueness","indexCreationRequest","mongoFieldNames","_ensureSparseUniqueIndexInBackground","_rawFind","count","distinct","isPointerField","substring","aggregate","pipeline","stage","$group","_parseAggregateGroupArgs","$match","_parseAggregateArgs","$project","_parseAggregateProjectArgs","results","split","isEmpty","returnValue","targetClass","_convertToDate","Date","PRIMARY","PRIMARY_PREFERRED","SECONDARY","SECONDARY_PREFERRED","NEAREST","performInitialization","createIndex","background","$text","indexName","textIndex","dropAllIndexes","dropIndexes","updateSchemaWithIndexes","classes","promises"],"mappings":"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","file":"MongoStorageAdapter.js","sourcesContent":["// @flow\nimport MongoCollection       from './MongoCollection';\nimport MongoSchemaCollection from './MongoSchemaCollection';\nimport { StorageAdapter }    from '../StorageAdapter';\nimport type { SchemaType,\n  QueryType,\n  StorageClass,\n  QueryOptions } from '../StorageAdapter';\nimport {\n  parse as parseUrl,\n  format as formatUrl,\n} from '../../../vendor/mongodbUrl';\nimport {\n  parseObjectToMongoObjectForCreate,\n  mongoObjectToParseObject,\n  transformKey,\n  transformWhere,\n  transformUpdate,\n  transformPointerString,\n} from './MongoTransform';\n// @flow-disable-next\nimport Parse                 from 'parse/node';\n// @flow-disable-next\nimport _                     from 'lodash';\nimport defaults              from '../../../defaults';\nimport logger                from '../../../logger';\n\n// @flow-disable-next\nconst mongodb = require('mongodb');\nconst MongoClient = mongodb.MongoClient;\nconst ReadPreference = mongodb.ReadPreference;\n\nconst MongoSchemaCollectionName = '_SCHEMA';\n\nconst storageAdapterAllCollections = mongoAdapter => {\n  return mongoAdapter.connect()\n    .then(() => mongoAdapter.database.collections())\n    .then(collections => {\n      return collections.filter(collection => {\n        if (collection.namespace.match(/\\.system\\./)) {\n          return false;\n        }\n        // TODO: If you have one app with a collection prefix that happens to be a prefix of another\n        // apps prefix, this will go very very badly. We should fix that somehow.\n        return (collection.collectionName.indexOf(mongoAdapter._collectionPrefix) == 0);\n      });\n    });\n}\n\nconst convertParseSchemaToMongoSchema = ({...schema}) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  if (schema.className === '_User') {\n    // Legacy mongo adapter knows about the difference between password and _hashed_password.\n    // Future database adapters will only know about _hashed_password.\n    // Note: Parse Server will bring back password with injectDefaultSchema, so we don't need\n    // to add _hashed_password back ever.\n    delete schema.fields._hashed_password;\n  }\n\n  return schema;\n}\n\n// Returns { code, error } if invalid, or { result }, an object\n// suitable for inserting into _SCHEMA collection, otherwise.\nconst mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPermissions, indexes) => {\n  const mongoObject = {\n    _id: className,\n    objectId: 'string',\n    updatedAt: 'string',\n    createdAt: 'string',\n    _metadata: undefined,\n  };\n\n  for (const fieldName in fields) {\n    mongoObject[fieldName] = MongoSchemaCollection.parseFieldTypeToMongoFieldType(fields[fieldName]);\n  }\n\n  if (typeof classLevelPermissions !== 'undefined') {\n    mongoObject._metadata = mongoObject._metadata || {};\n    if (!classLevelPermissions) {\n      delete mongoObject._metadata.class_permissions;\n    } else {\n      mongoObject._metadata.class_permissions = classLevelPermissions;\n    }\n  }\n\n  if (indexes && typeof indexes === 'object' && Object.keys(indexes).length > 0) {\n    mongoObject._metadata = mongoObject._metadata || {};\n    mongoObject._metadata.indexes = indexes;\n  }\n\n  if (!mongoObject._metadata) { // cleanup the unused _metadata\n    delete mongoObject._metadata;\n  }\n\n  return mongoObject;\n}\n\n\nexport class MongoStorageAdapter implements StorageAdapter {\n  // Private\n  _uri: string;\n  _collectionPrefix: string;\n  _mongoOptions: Object;\n  // Public\n  connectionPromise: Promise<any>;\n  database: any;\n  client: MongoClient;\n  _maxTimeMS: ?number;\n  canSortOnJoinTables: boolean;\n\n  constructor({\n    uri = defaults.DefaultMongoURI,\n    collectionPrefix = '',\n    mongoOptions = {},\n  }: any) {\n    this._uri = uri;\n    this._collectionPrefix = collectionPrefix;\n    this._mongoOptions = mongoOptions;\n\n    // MaxTimeMS is not a global MongoDB client option, it is applied per operation.\n    this._maxTimeMS = mongoOptions.maxTimeMS;\n    this.canSortOnJoinTables = true;\n    delete mongoOptions.maxTimeMS;\n  }\n\n  connect() {\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    // parsing and re-formatting causes the auth value (if there) to get URI\n    // encoded\n    const encodedUri = formatUrl(parseUrl(this._uri));\n\n    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(client => {\n      // Starting mongoDB 3.0, the MongoClient.connect don't return a DB anymore but a client\n      // Fortunately, we can get back the options and use them to select the proper DB.\n      // https://github.com/mongodb/node-mongodb-native/blob/2c35d76f08574225b8db02d7bef687123e6bb018/lib/mongo_client.js#L885\n      const options = client.s.options;\n      const database = client.db(options.dbName);\n      if (!database) {\n        delete this.connectionPromise;\n        return;\n      }\n      database.on('error', () => {\n        delete this.connectionPromise;\n      });\n      database.on('close', () => {\n        delete this.connectionPromise;\n      });\n      this.client = client;\n      this.database = database;\n    }).catch((err) => {\n      delete this.connectionPromise;\n      return Promise.reject(err);\n    });\n\n    return this.connectionPromise;\n  }\n\n  handleError<T>(error: ?(Error | Parse.Error)): Promise<T> {\n    if (error && error.code === 13) { // Unauthorized error\n      delete this.client;\n      delete this.database;\n      delete this.connectionPromise;\n      logger.error('Received unauthorized error', { error: error });\n    }\n    throw error;\n  }\n\n  handleShutdown() {\n    if (!this.client) {\n      return;\n    }\n    this.client.close(false);\n  }\n\n  _adaptiveCollection(name: string) {\n    return this.connect()\n      .then(() => this.database.collection(this._collectionPrefix + name))\n      .then(rawCollection => new MongoCollection(rawCollection))\n      .catch(err => this.handleError(err));\n  }\n\n  _schemaCollection(): Promise<MongoSchemaCollection> {\n    return this.connect()\n      .then(() => this._adaptiveCollection(MongoSchemaCollectionName))\n      .then(collection => new MongoSchemaCollection(collection));\n  }\n\n  classExists(name: string) {\n    return this.connect().then(() => {\n      return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();\n    }).then(collections => {\n      return collections.length > 0;\n    }).catch(err => this.handleError(err));\n  }\n\n  setClassLevelPermissions(className: string, CLPs: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.class_permissions': CLPs }\n      })).catch(err => this.handleError(err));\n  }\n\n  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any): Promise<void> {\n    if (submittedIndexes === undefined) {\n      return Promise.resolve();\n    }\n    if (Object.keys(existingIndexes).length === 0) {\n      existingIndexes = { _id_: { _id: 1} };\n    }\n    const deletePromises = [];\n    const insertedIndexes = [];\n    Object.keys(submittedIndexes).forEach(name => {\n      const field = submittedIndexes[name];\n      if (existingIndexes[name] && field.__op !== 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`);\n      }\n      if (!existingIndexes[name] && field.__op === 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`);\n      }\n      if (field.__op === 'Delete') {\n        const promise = this.dropIndex(className, name);\n        deletePromises.push(promise);\n        delete existingIndexes[name];\n      } else {\n        Object.keys(field).forEach(key => {\n          if (!fields.hasOwnProperty(key)) {\n            throw new Parse.Error(Parse.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`);\n          }\n        });\n        existingIndexes[name] = field;\n        insertedIndexes.push({\n          key: field,\n          name,\n        });\n      }\n    });\n    let insertPromise = Promise.resolve();\n    if (insertedIndexes.length > 0) {\n      insertPromise = this.createIndexes(className, insertedIndexes);\n    }\n    return Promise.all(deletePromises)\n      .then(() => insertPromise)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.indexes':  existingIndexes }\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  setIndexesFromMongo(className: string) {\n    return this.getIndexes(className).then((indexes) => {\n      indexes = indexes.reduce((obj, index) => {\n        if (index.key._fts) {\n          delete index.key._fts;\n          delete index.key._ftsx;\n          for (const field in index.weights) {\n            index.key[field] = 'text';\n          }\n        }\n        obj[index.name] = index.key;\n        return obj;\n      }, {});\n      return this._schemaCollection()\n        .then(schemaCollection => schemaCollection.updateSchema(className, {\n          $set: { '_metadata.indexes': indexes }\n        }));\n    })\n      .catch(err => this.handleError(err))\n      .catch(() => {\n        // Ignore if collection not found\n        return Promise.resolve();\n      });\n  }\n\n  createClass(className: string, schema: SchemaType): Promise<void> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions, schema.indexes);\n    mongoObject._id = className;\n    return this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.insertSchema(mongoObject))\n      .catch(err => this.handleError(err));\n  }\n\n  addFieldIfNotExists(className: string, fieldName: string, type: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type))\n      .then(() => this.createIndexesIfNeeded(className, fieldName, type))\n      .catch(err => this.handleError(err));\n  }\n\n  // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)\n  // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.\n  deleteClass(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection.drop())\n      .catch(error => {\n      // 'ns not found' means collection was already gone. Ignore deletion attempt.\n        if (error.message == 'ns not found') {\n          return;\n        }\n        throw error;\n      })\n    // We've dropped the collection, now remove the _SCHEMA document\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.findAndDeleteSchema(className))\n      .catch(err => this.handleError(err));\n  }\n\n  deleteAllClasses(fast: boolean) {\n    return storageAdapterAllCollections(this)\n      .then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop())));\n  }\n\n  // Remove the column and all the data. For Relations, the _Join collection is handled\n  // specially, this function does not delete _Join columns. It should, however, indicate\n  // that the relation fields does not exist anymore. In mongo, this means removing it from\n  // the _SCHEMA collection.  There should be no actual data in the collection under the same name\n  // as the relation column, so it's fine to attempt to delete it. If the fields listed to be\n  // deleted do not exist, this function should return successfully anyways. Checking for\n  // attempts to delete non-existent fields is the responsibility of Parse Server.\n\n  // Pointer field names are passed for legacy reasons: the original mongo\n  // format stored pointer field names differently in the database, and therefore\n  // needed to know the type of the field before it could delete it. Future database\n  // adapters should ignore the pointerFieldNames argument. All the field names are in\n  // fieldNames, they show up additionally in the pointerFieldNames database for use\n  // by the mongo adapter, which deals with the legacy mongo format.\n\n  // This function is not obligated to delete fields atomically. It is given the field\n  // names in a list so that databases that are capable of deleting fields atomically\n  // may do so.\n\n  // Returns a Promise.\n  deleteFields(className: string, schema: SchemaType, fieldNames: string[]) {\n    const mongoFormatNames = fieldNames.map(fieldName => {\n      if (schema.fields[fieldName].type === 'Pointer') {\n        return `_p_${fieldName}`\n      } else {\n        return fieldName;\n      }\n    });\n    const collectionUpdate = { '$unset' : {} };\n    mongoFormatNames.forEach(name => {\n      collectionUpdate['$unset'][name] = null;\n    });\n\n    const schemaUpdate = { '$unset' : {} };\n    fieldNames.forEach(name => {\n      schemaUpdate['$unset'][name] = null;\n    });\n\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany({}, collectionUpdate))\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for all schemas known to this adapter, in Parse format. In case the\n  // schemas cannot be retrieved, returns a promise that rejects. Requirements for the\n  // rejection reason are TBD.\n  getAllClasses(): Promise<StorageClass[]> {\n    return this._schemaCollection().then(schemasCollection => schemasCollection._fetchAllSchemasFrom_SCHEMA())\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for the schema with the given name, in Parse format. If\n  // this adapter doesn't know about the schema, return a promise that rejects with\n  // undefined as the reason.\n  getClass(className: string): Promise<StorageClass> {\n    return this._schemaCollection()\n      .then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className))\n      .catch(err => this.handleError(err));\n  }\n\n  // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema,\n  // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs\n  // the schema only for the legacy mongo format. We'll figure that out later.\n  createObject(className: string, schema: SchemaType, object: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = parseObjectToMongoObjectForCreate(className, object, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.insertOne(mongoObject))\n      .catch(error => {\n        if (error.code === 11000) { // Duplicate value\n          const err = new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          err.underlyingError = error;\n          if (error.message) {\n            const matches = error.message.match(/index:[\\sa-zA-Z0-9_\\-\\.]+\\$?([a-zA-Z_-]+)_1/);\n            if (matches && Array.isArray(matches)) {\n              err.userInfo = { duplicated_field: matches[1] };\n            }\n          }\n          throw err;\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Remove all objects that match the given Parse Query.\n  // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.\n  // If there is some other error, reject with INTERNAL_SERVER_ERROR.\n  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    return this._adaptiveCollection(className)\n      .then(collection => {\n        const mongoWhere = transformWhere(className, query, schema);\n        return collection.deleteMany(mongoWhere)\n      })\n      .catch(err => this.handleError(err))\n      .then(({ result }) => {\n        if (result.n === 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n        return Promise.resolve();\n      }, () => {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error');\n      });\n  }\n\n  // Apply the update to all objects that match the given Parse Query.\n  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Atomically finds and updates an object based on query.\n  // Return value not currently well specified.\n  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.findAndModify(mongoWhere, [], mongoUpdate, { new: true }))\n      .then(result => mongoObjectToParseObject(className, result.value, schema))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Hopefully we can get rid of this. It's only used for config and hooks.\n  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.upsertOne(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.\n  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptions): Promise<any> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));\n    const mongoKeys = _.reduce(keys, (memo, key) => {\n      memo[transformKey(className, key, schema)] = 1;\n      return memo;\n    }, {});\n\n    readPreference = this._parseReadPreference(readPreference);\n    return this.createTextIndexesIfNeeded(className, query, schema)\n      .then(() => this._adaptiveCollection(className))\n      .then(collection => collection.find(mongoWhere, {\n        skip,\n        limit,\n        sort: mongoSort,\n        keys: mongoKeys,\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't\n  // currently know which fields are nullable and which aren't, we ignore that criteria.\n  // As such, we shouldn't expose this function to users of parse until we have an out-of-band\n  // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,\n  // which is why we use sparse indexes.\n  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const indexCreationRequest = {};\n    const mongoFieldNames = fieldNames.map(fieldName => transformKey(className, fieldName, schema));\n    mongoFieldNames.forEach(fieldName => {\n      indexCreationRequest[fieldName] = 1;\n    });\n    return this._adaptiveCollection(className)\n      .then(collection => collection._ensureSparseUniqueIndexInBackground(indexCreationRequest))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Tried to ensure field uniqueness for a class that already has duplicates.');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Used in tests\n  _rawFind(className: string, query: QueryType) {\n    return this._adaptiveCollection(className).then(collection => collection.find(query, {\n      maxTimeMS: this._maxTimeMS,\n    })).catch(err => this.handleError(err));\n  }\n\n  // Executes a count.\n  count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.count(transformWhere(className, query, schema), {\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const isPointerField = schema.fields[fieldName] && schema.fields[fieldName].type === 'Pointer';\n    if (isPointerField) {\n      fieldName = `_p_${fieldName}`\n    }\n    return this._adaptiveCollection(className)\n      .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)))\n      .then(objects => {\n        objects = objects.filter((obj) => obj != null);\n        return objects.map(object => {\n          if (isPointerField) {\n            const field = fieldName.substring(3);\n            return transformPointerString(schema, field, object);\n          }\n          return mongoObjectToParseObject(className, object, schema);\n        });\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) {\n    let isPointerField = false;\n    pipeline = pipeline.map((stage) => {\n      if (stage.$group) {\n        stage.$group = this._parseAggregateGroupArgs(schema, stage.$group);\n        if (stage.$group._id && (typeof stage.$group._id === 'string') && stage.$group._id.indexOf('$_p_') >= 0) {\n          isPointerField = true;\n        }\n      }\n      if (stage.$match) {\n        stage.$match = this._parseAggregateArgs(schema, stage.$match);\n      }\n      if (stage.$project) {\n        stage.$project = this._parseAggregateProjectArgs(schema, stage.$project);\n      }\n      return stage;\n    });\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS }))\n      .catch(error => {\n        if (error.code === 16006) {\n          throw new Parse.Error(Parse.Error.INVALID_QUERY, error.message);\n        }\n        throw error;\n      })\n      .then(results => {\n        results.forEach(result => {\n          if (result.hasOwnProperty('_id')) {\n            if (isPointerField && result._id) {\n              result._id = result._id.split('$')[1];\n            }\n            if (result._id == null || _.isEmpty(result._id)) {\n              result._id = null;\n            }\n            result.objectId = result._id;\n            delete result._id;\n          }\n        });\n        return results;\n      })\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // This function will recursively traverse the pipeline and convert any Pointer or Date columns.\n  // If we detect a pointer column we will rename the column being queried for to match the column\n  // in the database. We also modify the value to what we expect the value to be in the database\n  // as well.\n  // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert\n  // the string to a Date so the driver can perform the necessary comparison.\n  //\n  // The goal of this method is to look for the \"leaves\" of the pipeline and determine if it needs\n  // to be converted. The pipeline can have a few different forms. For more details, see:\n  //     https://docs.mongodb.com/manual/reference/operator/aggregation/\n  //\n  // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In\n  // that case we need to loop through all of it's children to find the columns being operated on.\n  // If the pipeline is an object, then we'll loop through the keys checking to see if the key name\n  // matches one of the schema columns. If it does match a column and the column is a Pointer or\n  // a Date, then we'll convert the value as described above.\n  //\n  // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing\n  // down a tree to find a \"leaf node\" and checking to see if it needs to be converted.\n  _parseAggregateArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n          if (typeof pipeline[field] === 'object') {\n            // Pass objects down to MongoDB...this is more than likely an $exists operator.\n            returnValue[`_p_${field}`] = pipeline[field];\n          } else {\n            returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`;\n          }\n        } else if (schema.fields[field] && schema.fields[field].type === 'Date') {\n          returnValue[field] = this._convertToDate(pipeline[field]);\n        } else {\n          returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n        }\n\n        if (field === 'objectId') {\n          returnValue['_id'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'createdAt') {\n          returnValue['_created_at'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'updatedAt') {\n          returnValue['_updated_at'] = returnValue[field];\n          delete returnValue[field];\n        }\n      }\n      return returnValue;\n    }\n    return pipeline;\n  }\n\n  // This function is slightly different than the one above. Rather than trying to combine these\n  // two functions and making the code even harder to understand, I decided to split it up. The\n  // difference with this function is we are not transforming the values, only the keys of the\n  // pipeline.\n  _parseAggregateProjectArgs(schema: any, pipeline: any): any {\n    const returnValue = {};\n    for (const field in pipeline) {\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        returnValue[`_p_${field}`] = pipeline[field];\n      } else {\n        returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n      }\n\n      if (field === 'objectId') {\n        returnValue['_id'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'createdAt') {\n        returnValue['_created_at'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'updatedAt') {\n        returnValue['_updated_at'] = returnValue[field];\n        delete returnValue[field];\n      }\n    }\n    return returnValue;\n  }\n\n  // This function is slightly different than the two above. MongoDB $group aggregate looks like:\n  //     { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }\n  // The <expression> could be a column name, prefixed with the '$' character. We'll look for\n  // these <expression> and check to see if it is a 'Pointer' or if it's one of createdAt,\n  // updatedAt or objectId and change it accordingly.\n  _parseAggregateGroupArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateGroupArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]);\n      }\n      return returnValue;\n    } else if (typeof pipeline === 'string') {\n      const field = pipeline.substring(1);\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        return `$_p_${field}`;\n      } else if (field == 'createdAt') {\n        return '$_created_at';\n      } else if (field == 'updatedAt') {\n        return '$_updated_at';\n      }\n    }\n    return pipeline;\n  }\n\n  // This function will attempt to convert the provided value to a Date object. Since this is part\n  // of an aggregation pipeline, the value can either be a string or it can be another object with\n  // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a\n  // recursive method to traverse down to the \"leaf node\" which is going to be the string.\n  _convertToDate(value: any): any {\n    if (typeof value === 'string') {\n      return new Date(value);\n    }\n\n    const returnValue = {}\n    for (const field in value) {\n      returnValue[field] = this._convertToDate(value[field])\n    }\n    return returnValue;\n  }\n\n  _parseReadPreference(readPreference: ?string): ?string {\n    switch (readPreference) {\n    case 'PRIMARY':\n      readPreference = ReadPreference.PRIMARY;\n      break;\n    case 'PRIMARY_PREFERRED':\n      readPreference = ReadPreference.PRIMARY_PREFERRED;\n      break;\n    case 'SECONDARY':\n      readPreference = ReadPreference.SECONDARY;\n      break;\n    case 'SECONDARY_PREFERRED':\n      readPreference = ReadPreference.SECONDARY_PREFERRED;\n      break;\n    case 'NEAREST':\n      readPreference = ReadPreference.NEAREST;\n      break;\n    case undefined:\n      break;\n    default:\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');\n    }\n    return readPreference;\n  }\n\n  performInitialization(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  createIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndex(index, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexes(className: string, indexes: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndexes(indexes, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexesIfNeeded(className: string, fieldName: string, type: any) {\n    if (type && type.type === 'Polygon') {\n      const index = {\n        [fieldName]: '2dsphere'\n      };\n      return this.createIndex(className, index);\n    }\n    return Promise.resolve();\n  }\n\n  createTextIndexesIfNeeded(className: string, query: QueryType, schema: any): Promise<void> {\n    for(const fieldName in query) {\n      if (!query[fieldName] || !query[fieldName].$text) {\n        continue;\n      }\n      const existingIndexes = schema.indexes;\n      for (const key in existingIndexes) {\n        const index = existingIndexes[key];\n        if (index.hasOwnProperty(fieldName)) {\n          return Promise.resolve();\n        }\n      }\n      const indexName = `${fieldName}_text`;\n      const textIndex = {\n        [indexName]: { [fieldName]: 'text' }\n      };\n      return this.setIndexesWithSchemaFormat(className, textIndex, existingIndexes, schema.fields)\n        .catch((error) => {\n          if (error.code === 85) { // Index exist with different options\n            return this.setIndexesFromMongo(className);\n          }\n          throw error;\n        });\n    }\n    return Promise.resolve();\n  }\n\n  getIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.indexes())\n      .catch(err => this.handleError(err));\n  }\n\n  dropIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndex(index))\n      .catch(err => this.handleError(err));\n  }\n\n  dropAllIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndexes())\n      .catch(err => this.handleError(err));\n  }\n\n  updateSchemaWithIndexes(): Promise<any> {\n    return this.getAllClasses()\n      .then((classes) => {\n        const promises = classes.map((schema) => {\n          return this.setIndexesFromMongo(schema.className);\n        });\n        return Promise.all(promises);\n      })\n      .catch(err => this.handleError(err));\n  }\n}\n\nexport default MongoStorageAdapter;\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/Adapters/Storage/Mongo/MongoStorageAdapter.js"],"names":["mongodb","require","MongoClient","ReadPreference","MongoSchemaCollectionName","storageAdapterAllCollections","mongoAdapter","connect","then","database","collections","filter","collection","namespace","match","collectionName","indexOf","_collectionPrefix","convertParseSchemaToMongoSchema","schema","fields","_rperm","_wperm","className","_hashed_password","mongoSchemaFromFieldsAndClassNameAndCLP","classLevelPermissions","indexes","mongoObject","_id","objectId","updatedAt","createdAt","_metadata","undefined","fieldName","MongoSchemaCollection","parseFieldTypeToMongoFieldType","class_permissions","Object","keys","length","MongoStorageAdapter","constructor","uri","defaults","DefaultMongoURI","collectionPrefix","mongoOptions","_uri","_mongoOptions","useNewUrlParser","_maxTimeMS","maxTimeMS","canSortOnJoinTables","connectionPromise","encodedUri","client","options","s","db","dbName","on","catch","err","Promise","reject","handleError","error","code","logger","handleShutdown","close","_adaptiveCollection","name","rawCollection","MongoCollection","_schemaCollection","classExists","listCollections","toArray","setClassLevelPermissions","CLPs","schemaCollection","updateSchema","$set","setIndexesWithSchemaFormat","submittedIndexes","existingIndexes","resolve","_id_","deletePromises","insertedIndexes","forEach","field","__op","Parse","Error","INVALID_QUERY","promise","dropIndex","push","key","hasOwnProperty","insertPromise","createIndexes","all","setIndexesFromMongo","getIndexes","reduce","obj","index","_fts","_ftsx","weights","createClass","insertSchema","addFieldIfNotExists","type","createIndexesIfNeeded","deleteClass","drop","message","findAndDeleteSchema","deleteAllClasses","fast","map","remove","deleteFields","fieldNames","mongoFormatNames","collectionUpdate","schemaUpdate","updateMany","getAllClasses","schemasCollection","_fetchAllSchemasFrom_SCHEMA","getClass","_fetchOneSchemaFrom_SCHEMA","createObject","object","insertOne","DUPLICATE_VALUE","underlyingError","matches","Array","isArray","userInfo","duplicated_field","deleteObjectsByQuery","query","mongoWhere","deleteMany","result","n","OBJECT_NOT_FOUND","INTERNAL_SERVER_ERROR","updateObjectsByQuery","update","mongoUpdate","findOneAndUpdate","_mongoCollection","findAndModify","new","value","upsertOneObject","upsertOne","find","skip","limit","sort","readPreference","mongoSort","_","mapKeys","mongoKeys","memo","_parseReadPreference","createTextIndexesIfNeeded","objects","ensureUniqueness","indexCreationRequest","mongoFieldNames","_ensureSparseUniqueIndexInBackground","_rawFind","count","distinct","isPointerField","substring","aggregate","pipeline","stage","$group","_parseAggregateGroupArgs","$match","_parseAggregateArgs","$project","_parseAggregateProjectArgs","results","split","isEmpty","returnValue","targetClass","_convertToDate","Date","PRIMARY","PRIMARY_PREFERRED","SECONDARY","SECONDARY_PREFERRED","NEAREST","performInitialization","createIndex","background","$text","indexName","textIndex","dropAllIndexes","dropIndexes","updateSchemaWithIndexes","classes","promises"],"mappings":"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","file":"MongoStorageAdapter.js","sourcesContent":["// @flow\nimport MongoCollection       from './MongoCollection';\nimport MongoSchemaCollection from './MongoSchemaCollection';\nimport { StorageAdapter }    from '../StorageAdapter';\nimport type { SchemaType,\n  QueryType,\n  StorageClass,\n  QueryOptions } from '../StorageAdapter';\nimport {\n  parse as parseUrl,\n  format as formatUrl,\n} from '../../../vendor/mongodbUrl';\nimport {\n  parseObjectToMongoObjectForCreate,\n  mongoObjectToParseObject,\n  transformKey,\n  transformWhere,\n  transformUpdate,\n  transformPointerString,\n} from './MongoTransform';\n// @flow-disable-next\nimport Parse                 from 'parse/node';\n// @flow-disable-next\nimport _                     from 'lodash';\nimport defaults              from '../../../defaults';\nimport logger                from '../../../logger';\n\n// @flow-disable-next\nconst mongodb = require('mongodb');\nconst MongoClient = mongodb.MongoClient;\nconst ReadPreference = mongodb.ReadPreference;\n\nconst MongoSchemaCollectionName = '_SCHEMA';\n\nconst storageAdapterAllCollections = mongoAdapter => {\n  return mongoAdapter.connect()\n    .then(() => mongoAdapter.database.collections())\n    .then(collections => {\n      return collections.filter(collection => {\n        if (collection.namespace.match(/\\.system\\./)) {\n          return false;\n        }\n        // TODO: If you have one app with a collection prefix that happens to be a prefix of another\n        // apps prefix, this will go very very badly. We should fix that somehow.\n        return (collection.collectionName.indexOf(mongoAdapter._collectionPrefix) == 0);\n      });\n    });\n}\n\nconst convertParseSchemaToMongoSchema = ({...schema}) => {\n  delete schema.fields._rperm;\n  delete schema.fields._wperm;\n\n  if (schema.className === '_User') {\n    // Legacy mongo adapter knows about the difference between password and _hashed_password.\n    // Future database adapters will only know about _hashed_password.\n    // Note: Parse Server will bring back password with injectDefaultSchema, so we don't need\n    // to add _hashed_password back ever.\n    delete schema.fields._hashed_password;\n  }\n\n  return schema;\n}\n\n// Returns { code, error } if invalid, or { result }, an object\n// suitable for inserting into _SCHEMA collection, otherwise.\nconst mongoSchemaFromFieldsAndClassNameAndCLP = (fields, className, classLevelPermissions, indexes) => {\n  const mongoObject = {\n    _id: className,\n    objectId: 'string',\n    updatedAt: 'string',\n    createdAt: 'string',\n    _metadata: undefined,\n  };\n\n  for (const fieldName in fields) {\n    mongoObject[fieldName] = MongoSchemaCollection.parseFieldTypeToMongoFieldType(fields[fieldName]);\n  }\n\n  if (typeof classLevelPermissions !== 'undefined') {\n    mongoObject._metadata = mongoObject._metadata || {};\n    if (!classLevelPermissions) {\n      delete mongoObject._metadata.class_permissions;\n    } else {\n      mongoObject._metadata.class_permissions = classLevelPermissions;\n    }\n  }\n\n  if (indexes && typeof indexes === 'object' && Object.keys(indexes).length > 0) {\n    mongoObject._metadata = mongoObject._metadata || {};\n    mongoObject._metadata.indexes = indexes;\n  }\n\n  if (!mongoObject._metadata) { // cleanup the unused _metadata\n    delete mongoObject._metadata;\n  }\n\n  return mongoObject;\n}\n\n\nexport class MongoStorageAdapter implements StorageAdapter {\n  // Private\n  _uri: string;\n  _collectionPrefix: string;\n  _mongoOptions: Object;\n  // Public\n  connectionPromise: Promise<any>;\n  database: any;\n  client: MongoClient;\n  _maxTimeMS: ?number;\n  canSortOnJoinTables: boolean;\n\n  constructor({\n    uri = defaults.DefaultMongoURI,\n    collectionPrefix = '',\n    mongoOptions = {},\n  }: any) {\n    this._uri = uri;\n    this._collectionPrefix = collectionPrefix;\n    this._mongoOptions = mongoOptions;\n    this._mongoOptions.useNewUrlParser = true;\n\n    // MaxTimeMS is not a global MongoDB client option, it is applied per operation.\n    this._maxTimeMS = mongoOptions.maxTimeMS;\n    this.canSortOnJoinTables = true;\n    delete mongoOptions.maxTimeMS;\n  }\n\n  connect() {\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    // parsing and re-formatting causes the auth value (if there) to get URI\n    // encoded\n    const encodedUri = formatUrl(parseUrl(this._uri));\n\n    this.connectionPromise = MongoClient.connect(encodedUri, this._mongoOptions).then(client => {\n      // Starting mongoDB 3.0, the MongoClient.connect don't return a DB anymore but a client\n      // Fortunately, we can get back the options and use them to select the proper DB.\n      // https://github.com/mongodb/node-mongodb-native/blob/2c35d76f08574225b8db02d7bef687123e6bb018/lib/mongo_client.js#L885\n      const options = client.s.options;\n      const database = client.db(options.dbName);\n      if (!database) {\n        delete this.connectionPromise;\n        return;\n      }\n      database.on('error', () => {\n        delete this.connectionPromise;\n      });\n      database.on('close', () => {\n        delete this.connectionPromise;\n      });\n      this.client = client;\n      this.database = database;\n    }).catch((err) => {\n      delete this.connectionPromise;\n      return Promise.reject(err);\n    });\n\n    return this.connectionPromise;\n  }\n\n  handleError<T>(error: ?(Error | Parse.Error)): Promise<T> {\n    if (error && error.code === 13) { // Unauthorized error\n      delete this.client;\n      delete this.database;\n      delete this.connectionPromise;\n      logger.error('Received unauthorized error', { error: error });\n    }\n    throw error;\n  }\n\n  handleShutdown() {\n    if (!this.client) {\n      return;\n    }\n    this.client.close(false);\n  }\n\n  _adaptiveCollection(name: string) {\n    return this.connect()\n      .then(() => this.database.collection(this._collectionPrefix + name))\n      .then(rawCollection => new MongoCollection(rawCollection))\n      .catch(err => this.handleError(err));\n  }\n\n  _schemaCollection(): Promise<MongoSchemaCollection> {\n    return this.connect()\n      .then(() => this._adaptiveCollection(MongoSchemaCollectionName))\n      .then(collection => new MongoSchemaCollection(collection));\n  }\n\n  classExists(name: string) {\n    return this.connect().then(() => {\n      return this.database.listCollections({ name: this._collectionPrefix + name }).toArray();\n    }).then(collections => {\n      return collections.length > 0;\n    }).catch(err => this.handleError(err));\n  }\n\n  setClassLevelPermissions(className: string, CLPs: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.class_permissions': CLPs }\n      })).catch(err => this.handleError(err));\n  }\n\n  setIndexesWithSchemaFormat(className: string, submittedIndexes: any, existingIndexes: any = {}, fields: any): Promise<void> {\n    if (submittedIndexes === undefined) {\n      return Promise.resolve();\n    }\n    if (Object.keys(existingIndexes).length === 0) {\n      existingIndexes = { _id_: { _id: 1} };\n    }\n    const deletePromises = [];\n    const insertedIndexes = [];\n    Object.keys(submittedIndexes).forEach(name => {\n      const field = submittedIndexes[name];\n      if (existingIndexes[name] && field.__op !== 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} exists, cannot update.`);\n      }\n      if (!existingIndexes[name] && field.__op === 'Delete') {\n        throw new Parse.Error(Parse.Error.INVALID_QUERY, `Index ${name} does not exist, cannot delete.`);\n      }\n      if (field.__op === 'Delete') {\n        const promise = this.dropIndex(className, name);\n        deletePromises.push(promise);\n        delete existingIndexes[name];\n      } else {\n        Object.keys(field).forEach(key => {\n          if (!fields.hasOwnProperty(key)) {\n            throw new Parse.Error(Parse.Error.INVALID_QUERY, `Field ${key} does not exist, cannot add index.`);\n          }\n        });\n        existingIndexes[name] = field;\n        insertedIndexes.push({\n          key: field,\n          name,\n        });\n      }\n    });\n    let insertPromise = Promise.resolve();\n    if (insertedIndexes.length > 0) {\n      insertPromise = this.createIndexes(className, insertedIndexes);\n    }\n    return Promise.all(deletePromises)\n      .then(() => insertPromise)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, {\n        $set: { '_metadata.indexes':  existingIndexes }\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  setIndexesFromMongo(className: string) {\n    return this.getIndexes(className).then((indexes) => {\n      indexes = indexes.reduce((obj, index) => {\n        if (index.key._fts) {\n          delete index.key._fts;\n          delete index.key._ftsx;\n          for (const field in index.weights) {\n            index.key[field] = 'text';\n          }\n        }\n        obj[index.name] = index.key;\n        return obj;\n      }, {});\n      return this._schemaCollection()\n        .then(schemaCollection => schemaCollection.updateSchema(className, {\n          $set: { '_metadata.indexes': indexes }\n        }));\n    })\n      .catch(err => this.handleError(err))\n      .catch(() => {\n        // Ignore if collection not found\n        return Promise.resolve();\n      });\n  }\n\n  createClass(className: string, schema: SchemaType): Promise<void> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = mongoSchemaFromFieldsAndClassNameAndCLP(schema.fields, className, schema.classLevelPermissions, schema.indexes);\n    mongoObject._id = className;\n    return this.setIndexesWithSchemaFormat(className, schema.indexes, {}, schema.fields)\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.insertSchema(mongoObject))\n      .catch(err => this.handleError(err));\n  }\n\n  addFieldIfNotExists(className: string, fieldName: string, type: any): Promise<void> {\n    return this._schemaCollection()\n      .then(schemaCollection => schemaCollection.addFieldIfNotExists(className, fieldName, type))\n      .then(() => this.createIndexesIfNeeded(className, fieldName, type))\n      .catch(err => this.handleError(err));\n  }\n\n  // Drops a collection. Resolves with true if it was a Parse Schema (eg. _User, Custom, etc.)\n  // and resolves with false if it wasn't (eg. a join table). Rejects if deletion was impossible.\n  deleteClass(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection.drop())\n      .catch(error => {\n      // 'ns not found' means collection was already gone. Ignore deletion attempt.\n        if (error.message == 'ns not found') {\n          return;\n        }\n        throw error;\n      })\n    // We've dropped the collection, now remove the _SCHEMA document\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.findAndDeleteSchema(className))\n      .catch(err => this.handleError(err));\n  }\n\n  deleteAllClasses(fast: boolean) {\n    return storageAdapterAllCollections(this)\n      .then(collections => Promise.all(collections.map(collection => fast ? collection.remove({}) : collection.drop())));\n  }\n\n  // Remove the column and all the data. For Relations, the _Join collection is handled\n  // specially, this function does not delete _Join columns. It should, however, indicate\n  // that the relation fields does not exist anymore. In mongo, this means removing it from\n  // the _SCHEMA collection.  There should be no actual data in the collection under the same name\n  // as the relation column, so it's fine to attempt to delete it. If the fields listed to be\n  // deleted do not exist, this function should return successfully anyways. Checking for\n  // attempts to delete non-existent fields is the responsibility of Parse Server.\n\n  // Pointer field names are passed for legacy reasons: the original mongo\n  // format stored pointer field names differently in the database, and therefore\n  // needed to know the type of the field before it could delete it. Future database\n  // adapters should ignore the pointerFieldNames argument. All the field names are in\n  // fieldNames, they show up additionally in the pointerFieldNames database for use\n  // by the mongo adapter, which deals with the legacy mongo format.\n\n  // This function is not obligated to delete fields atomically. It is given the field\n  // names in a list so that databases that are capable of deleting fields atomically\n  // may do so.\n\n  // Returns a Promise.\n  deleteFields(className: string, schema: SchemaType, fieldNames: string[]) {\n    const mongoFormatNames = fieldNames.map(fieldName => {\n      if (schema.fields[fieldName].type === 'Pointer') {\n        return `_p_${fieldName}`\n      } else {\n        return fieldName;\n      }\n    });\n    const collectionUpdate = { '$unset' : {} };\n    mongoFormatNames.forEach(name => {\n      collectionUpdate['$unset'][name] = null;\n    });\n\n    const schemaUpdate = { '$unset' : {} };\n    fieldNames.forEach(name => {\n      schemaUpdate['$unset'][name] = null;\n    });\n\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany({}, collectionUpdate))\n      .then(() => this._schemaCollection())\n      .then(schemaCollection => schemaCollection.updateSchema(className, schemaUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for all schemas known to this adapter, in Parse format. In case the\n  // schemas cannot be retrieved, returns a promise that rejects. Requirements for the\n  // rejection reason are TBD.\n  getAllClasses(): Promise<StorageClass[]> {\n    return this._schemaCollection().then(schemasCollection => schemasCollection._fetchAllSchemasFrom_SCHEMA())\n      .catch(err => this.handleError(err));\n  }\n\n  // Return a promise for the schema with the given name, in Parse format. If\n  // this adapter doesn't know about the schema, return a promise that rejects with\n  // undefined as the reason.\n  getClass(className: string): Promise<StorageClass> {\n    return this._schemaCollection()\n      .then(schemasCollection => schemasCollection._fetchOneSchemaFrom_SCHEMA(className))\n      .catch(err => this.handleError(err));\n  }\n\n  // TODO: As yet not particularly well specified. Creates an object. Maybe shouldn't even need the schema,\n  // and should infer from the type. Or maybe does need the schema for validations. Or maybe needs\n  // the schema only for the legacy mongo format. We'll figure that out later.\n  createObject(className: string, schema: SchemaType, object: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoObject = parseObjectToMongoObjectForCreate(className, object, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.insertOne(mongoObject))\n      .catch(error => {\n        if (error.code === 11000) { // Duplicate value\n          const err = new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n          err.underlyingError = error;\n          if (error.message) {\n            const matches = error.message.match(/index:[\\sa-zA-Z0-9_\\-\\.]+\\$?([a-zA-Z_-]+)_1/);\n            if (matches && Array.isArray(matches)) {\n              err.userInfo = { duplicated_field: matches[1] };\n            }\n          }\n          throw err;\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Remove all objects that match the given Parse Query.\n  // If no objects match, reject with OBJECT_NOT_FOUND. If objects are found and deleted, resolve with undefined.\n  // If there is some other error, reject with INTERNAL_SERVER_ERROR.\n  deleteObjectsByQuery(className: string, schema: SchemaType, query: QueryType) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    return this._adaptiveCollection(className)\n      .then(collection => {\n        const mongoWhere = transformWhere(className, query, schema);\n        return collection.deleteMany(mongoWhere)\n      })\n      .catch(err => this.handleError(err))\n      .then(({ result }) => {\n        if (result.n === 0) {\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n        }\n        return Promise.resolve();\n      }, () => {\n        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error');\n      });\n  }\n\n  // Apply the update to all objects that match the given Parse Query.\n  updateObjectsByQuery(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.updateMany(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Atomically finds and updates an object based on query.\n  // Return value not currently well specified.\n  findOneAndUpdate(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.findAndModify(mongoWhere, [], mongoUpdate, { new: true }))\n      .then(result => mongoObjectToParseObject(className, result.value, schema))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'A duplicate value for a field with unique values was provided');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Hopefully we can get rid of this. It's only used for config and hooks.\n  upsertOneObject(className: string, schema: SchemaType, query: QueryType, update: any) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoUpdate = transformUpdate(className, update, schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.upsertOne(mongoWhere, mongoUpdate))\n      .catch(err => this.handleError(err));\n  }\n\n  // Executes a find. Accepts: className, query in Parse format, and { skip, limit, sort }.\n  find(className: string, schema: SchemaType, query: QueryType, { skip, limit, sort, keys, readPreference }: QueryOptions): Promise<any> {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const mongoWhere = transformWhere(className, query, schema);\n    const mongoSort = _.mapKeys(sort, (value, fieldName) => transformKey(className, fieldName, schema));\n    const mongoKeys = _.reduce(keys, (memo, key) => {\n      memo[transformKey(className, key, schema)] = 1;\n      return memo;\n    }, {});\n\n    readPreference = this._parseReadPreference(readPreference);\n    return this.createTextIndexesIfNeeded(className, query, schema)\n      .then(() => this._adaptiveCollection(className))\n      .then(collection => collection.find(mongoWhere, {\n        skip,\n        limit,\n        sort: mongoSort,\n        keys: mongoKeys,\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't\n  // currently know which fields are nullable and which aren't, we ignore that criteria.\n  // As such, we shouldn't expose this function to users of parse until we have an out-of-band\n  // Way of determining if a field is nullable. Undefined doesn't count against uniqueness,\n  // which is why we use sparse indexes.\n  ensureUniqueness(className: string, schema: SchemaType, fieldNames: string[]) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const indexCreationRequest = {};\n    const mongoFieldNames = fieldNames.map(fieldName => transformKey(className, fieldName, schema));\n    mongoFieldNames.forEach(fieldName => {\n      indexCreationRequest[fieldName] = 1;\n    });\n    return this._adaptiveCollection(className)\n      .then(collection => collection._ensureSparseUniqueIndexInBackground(indexCreationRequest))\n      .catch(error => {\n        if (error.code === 11000) {\n          throw new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Tried to ensure field uniqueness for a class that already has duplicates.');\n        }\n        throw error;\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  // Used in tests\n  _rawFind(className: string, query: QueryType) {\n    return this._adaptiveCollection(className).then(collection => collection.find(query, {\n      maxTimeMS: this._maxTimeMS,\n    })).catch(err => this.handleError(err));\n  }\n\n  // Executes a count.\n  count(className: string, schema: SchemaType, query: QueryType, readPreference: ?string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.count(transformWhere(className, query, schema), {\n        maxTimeMS: this._maxTimeMS,\n        readPreference,\n      }))\n      .catch(err => this.handleError(err));\n  }\n\n  distinct(className: string, schema: SchemaType, query: QueryType, fieldName: string) {\n    schema = convertParseSchemaToMongoSchema(schema);\n    const isPointerField = schema.fields[fieldName] && schema.fields[fieldName].type === 'Pointer';\n    if (isPointerField) {\n      fieldName = `_p_${fieldName}`\n    }\n    return this._adaptiveCollection(className)\n      .then(collection => collection.distinct(fieldName, transformWhere(className, query, schema)))\n      .then(objects => {\n        objects = objects.filter((obj) => obj != null);\n        return objects.map(object => {\n          if (isPointerField) {\n            const field = fieldName.substring(3);\n            return transformPointerString(schema, field, object);\n          }\n          return mongoObjectToParseObject(className, object, schema);\n        });\n      })\n      .catch(err => this.handleError(err));\n  }\n\n  aggregate(className: string, schema: any, pipeline: any, readPreference: ?string) {\n    let isPointerField = false;\n    pipeline = pipeline.map((stage) => {\n      if (stage.$group) {\n        stage.$group = this._parseAggregateGroupArgs(schema, stage.$group);\n        if (stage.$group._id && (typeof stage.$group._id === 'string') && stage.$group._id.indexOf('$_p_') >= 0) {\n          isPointerField = true;\n        }\n      }\n      if (stage.$match) {\n        stage.$match = this._parseAggregateArgs(schema, stage.$match);\n      }\n      if (stage.$project) {\n        stage.$project = this._parseAggregateProjectArgs(schema, stage.$project);\n      }\n      return stage;\n    });\n    readPreference = this._parseReadPreference(readPreference);\n    return this._adaptiveCollection(className)\n      .then(collection => collection.aggregate(pipeline, { readPreference, maxTimeMS: this._maxTimeMS }))\n      .catch(error => {\n        if (error.code === 16006) {\n          throw new Parse.Error(Parse.Error.INVALID_QUERY, error.message);\n        }\n        throw error;\n      })\n      .then(results => {\n        results.forEach(result => {\n          if (result.hasOwnProperty('_id')) {\n            if (isPointerField && result._id) {\n              result._id = result._id.split('$')[1];\n            }\n            if (result._id == null || _.isEmpty(result._id)) {\n              result._id = null;\n            }\n            result.objectId = result._id;\n            delete result._id;\n          }\n        });\n        return results;\n      })\n      .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)))\n      .catch(err => this.handleError(err));\n  }\n\n  // This function will recursively traverse the pipeline and convert any Pointer or Date columns.\n  // If we detect a pointer column we will rename the column being queried for to match the column\n  // in the database. We also modify the value to what we expect the value to be in the database\n  // as well.\n  // For dates, the driver expects a Date object, but we have a string coming in. So we'll convert\n  // the string to a Date so the driver can perform the necessary comparison.\n  //\n  // The goal of this method is to look for the \"leaves\" of the pipeline and determine if it needs\n  // to be converted. The pipeline can have a few different forms. For more details, see:\n  //     https://docs.mongodb.com/manual/reference/operator/aggregation/\n  //\n  // If the pipeline is an array, it means we are probably parsing an '$and' or '$or' operator. In\n  // that case we need to loop through all of it's children to find the columns being operated on.\n  // If the pipeline is an object, then we'll loop through the keys checking to see if the key name\n  // matches one of the schema columns. If it does match a column and the column is a Pointer or\n  // a Date, then we'll convert the value as described above.\n  //\n  // As much as I hate recursion...this seemed like a good fit for it. We're essentially traversing\n  // down a tree to find a \"leaf node\" and checking to see if it needs to be converted.\n  _parseAggregateArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n          if (typeof pipeline[field] === 'object') {\n            // Pass objects down to MongoDB...this is more than likely an $exists operator.\n            returnValue[`_p_${field}`] = pipeline[field];\n          } else {\n            returnValue[`_p_${field}`] = `${schema.fields[field].targetClass}$${pipeline[field]}`;\n          }\n        } else if (schema.fields[field] && schema.fields[field].type === 'Date') {\n          returnValue[field] = this._convertToDate(pipeline[field]);\n        } else {\n          returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n        }\n\n        if (field === 'objectId') {\n          returnValue['_id'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'createdAt') {\n          returnValue['_created_at'] = returnValue[field];\n          delete returnValue[field];\n        } else if (field === 'updatedAt') {\n          returnValue['_updated_at'] = returnValue[field];\n          delete returnValue[field];\n        }\n      }\n      return returnValue;\n    }\n    return pipeline;\n  }\n\n  // This function is slightly different than the one above. Rather than trying to combine these\n  // two functions and making the code even harder to understand, I decided to split it up. The\n  // difference with this function is we are not transforming the values, only the keys of the\n  // pipeline.\n  _parseAggregateProjectArgs(schema: any, pipeline: any): any {\n    const returnValue = {};\n    for (const field in pipeline) {\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        returnValue[`_p_${field}`] = pipeline[field];\n      } else {\n        returnValue[field] = this._parseAggregateArgs(schema, pipeline[field]);\n      }\n\n      if (field === 'objectId') {\n        returnValue['_id'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'createdAt') {\n        returnValue['_created_at'] = returnValue[field];\n        delete returnValue[field];\n      } else if (field === 'updatedAt') {\n        returnValue['_updated_at'] = returnValue[field];\n        delete returnValue[field];\n      }\n    }\n    return returnValue;\n  }\n\n  // This function is slightly different than the two above. MongoDB $group aggregate looks like:\n  //     { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }\n  // The <expression> could be a column name, prefixed with the '$' character. We'll look for\n  // these <expression> and check to see if it is a 'Pointer' or if it's one of createdAt,\n  // updatedAt or objectId and change it accordingly.\n  _parseAggregateGroupArgs(schema: any, pipeline: any): any {\n    if (Array.isArray(pipeline)) {\n      return pipeline.map((value) => this._parseAggregateGroupArgs(schema, value));\n    } else if (typeof pipeline === 'object') {\n      const returnValue = {};\n      for (const field in pipeline) {\n        returnValue[field] = this._parseAggregateGroupArgs(schema, pipeline[field]);\n      }\n      return returnValue;\n    } else if (typeof pipeline === 'string') {\n      const field = pipeline.substring(1);\n      if (schema.fields[field] && schema.fields[field].type === 'Pointer') {\n        return `$_p_${field}`;\n      } else if (field == 'createdAt') {\n        return '$_created_at';\n      } else if (field == 'updatedAt') {\n        return '$_updated_at';\n      }\n    }\n    return pipeline;\n  }\n\n  // This function will attempt to convert the provided value to a Date object. Since this is part\n  // of an aggregation pipeline, the value can either be a string or it can be another object with\n  // an operator in it (like $gt, $lt, etc). Because of this I felt it was easier to make this a\n  // recursive method to traverse down to the \"leaf node\" which is going to be the string.\n  _convertToDate(value: any): any {\n    if (typeof value === 'string') {\n      return new Date(value);\n    }\n\n    const returnValue = {}\n    for (const field in value) {\n      returnValue[field] = this._convertToDate(value[field])\n    }\n    return returnValue;\n  }\n\n  _parseReadPreference(readPreference: ?string): ?string {\n    switch (readPreference) {\n    case 'PRIMARY':\n      readPreference = ReadPreference.PRIMARY;\n      break;\n    case 'PRIMARY_PREFERRED':\n      readPreference = ReadPreference.PRIMARY_PREFERRED;\n      break;\n    case 'SECONDARY':\n      readPreference = ReadPreference.SECONDARY;\n      break;\n    case 'SECONDARY_PREFERRED':\n      readPreference = ReadPreference.SECONDARY_PREFERRED;\n      break;\n    case 'NEAREST':\n      readPreference = ReadPreference.NEAREST;\n      break;\n    case undefined:\n      break;\n    default:\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Not supported read preference.');\n    }\n    return readPreference;\n  }\n\n  performInitialization(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  createIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndex(index, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexes(className: string, indexes: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.createIndexes(indexes, {background: true}))\n      .catch(err => this.handleError(err));\n  }\n\n  createIndexesIfNeeded(className: string, fieldName: string, type: any) {\n    if (type && type.type === 'Polygon') {\n      const index = {\n        [fieldName]: '2dsphere'\n      };\n      return this.createIndex(className, index);\n    }\n    return Promise.resolve();\n  }\n\n  createTextIndexesIfNeeded(className: string, query: QueryType, schema: any): Promise<void> {\n    for(const fieldName in query) {\n      if (!query[fieldName] || !query[fieldName].$text) {\n        continue;\n      }\n      const existingIndexes = schema.indexes;\n      for (const key in existingIndexes) {\n        const index = existingIndexes[key];\n        if (index.hasOwnProperty(fieldName)) {\n          return Promise.resolve();\n        }\n      }\n      const indexName = `${fieldName}_text`;\n      const textIndex = {\n        [indexName]: { [fieldName]: 'text' }\n      };\n      return this.setIndexesWithSchemaFormat(className, textIndex, existingIndexes, schema.fields)\n        .catch((error) => {\n          if (error.code === 85) { // Index exist with different options\n            return this.setIndexesFromMongo(className);\n          }\n          throw error;\n        });\n    }\n    return Promise.resolve();\n  }\n\n  getIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.indexes())\n      .catch(err => this.handleError(err));\n  }\n\n  dropIndex(className: string, index: any) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndex(index))\n      .catch(err => this.handleError(err));\n  }\n\n  dropAllIndexes(className: string) {\n    return this._adaptiveCollection(className)\n      .then(collection => collection._mongoCollection.dropIndexes())\n      .catch(err => this.handleError(err));\n  }\n\n  updateSchemaWithIndexes(): Promise<any> {\n    return this.getAllClasses()\n      .then((classes) => {\n        const promises = classes.map((schema) => {\n          return this.setIndexesFromMongo(schema.className);\n        });\n        return Promise.all(promises);\n      })\n      .catch(err => this.handleError(err));\n  }\n}\n\nexport default MongoStorageAdapter;\n"]} \ No newline at end of file From cab9edf94d7a0312048ef18f6ce8251aef5eed26 Mon Sep 17 00:00:00 2001 From: Ricardo Paiva Date: Wed, 31 Oct 2018 13:46:13 -0300 Subject: [PATCH 15/73] Merge from 3.1.0 --- .babelrc | 6 +- .eslintrc.json | 2 +- .github/ISSUE_TEMPLATE.md | 12 +- .../ISSUE_TEMPLATE/---parse-server-3-0-0.md | 54 + .../ISSUE_TEMPLATE/---push-notifications.md | 44 + .github/ISSUE_TEMPLATE/---report-an-issue.md | 6 +- .github/stale.yml | 19 + .gitignore | 4 + .prettierrc | 3 + .travis.yml | 11 +- 3.0.0.md | 226 + CHANGELOG.md | 65 +- README.md | 17 +- bin/dev | 41 +- jsdoc-conf.json | 23 + lib/AccountLockout.js | 78 +- lib/Adapters/AdapterLoader.js | 38 +- lib/Adapters/Analytics/AnalyticsAdapter.js | 34 +- lib/Adapters/Auth/AuthAdapter.js | 12 +- lib/Adapters/Auth/OAuth1Client.js | 114 +- lib/Adapters/Auth/facebook.js | 42 +- lib/Adapters/Auth/facebookaccountkit.js | 44 +- lib/Adapters/Auth/github.js | 49 +- lib/Adapters/Auth/google.js | 46 +- lib/Adapters/Auth/httpsRequest.js | 47 + lib/Adapters/Auth/index.js | 75 +- lib/Adapters/Auth/instagram.js | 35 +- lib/Adapters/Auth/janraincapture.js | 44 +- lib/Adapters/Auth/janrainengage.js | 56 +- lib/Adapters/Auth/linkedin.js | 45 +- lib/Adapters/Auth/meetup.js | 47 +- lib/Adapters/Auth/qq.js | 60 +- lib/Adapters/Auth/spotify.js | 52 +- lib/Adapters/Auth/twitter.js | 25 +- lib/Adapters/Auth/vkontakte.js | 48 +- lib/Adapters/Auth/wechat.js | 39 +- lib/Adapters/Auth/weibo.js | 68 +- lib/Adapters/Cache/CacheAdapter.js | 35 +- lib/Adapters/Cache/InMemoryCache.js | 17 +- lib/Adapters/Cache/InMemoryCacheAdapter.js | 15 +- lib/Adapters/Cache/LRUCache.js | 23 +- lib/Adapters/Cache/NullCacheAdapter.js | 9 +- lib/Adapters/Cache/RedisCacheAdapter.js | 28 +- lib/Adapters/Email/MailAdapter.js | 24 +- lib/Adapters/Files/FilesAdapter.js | 66 +- lib/Adapters/Files/GridFSBucketAdapter.js | 101 + lib/Adapters/Files/GridStoreAdapter.js | 47 +- lib/Adapters/Logger/LoggerAdapter.js | 38 +- lib/Adapters/Logger/WinstonLogger.js | 97 +- lib/Adapters/Logger/WinstonLoggerAdapter.js | 27 +- lib/Adapters/MessageQueue/EventEmitterMQ.js | 26 +- lib/Adapters/PubSub/EventEmitterPubSub.js | 21 +- lib/Adapters/PubSub/PubSubAdapter.js | 39 + lib/Adapters/PubSub/RedisPubSub.js | 68 +- lib/Adapters/Push/PushAdapter.js | 23 +- lib/Adapters/Storage/Mongo/MongoCollection.js | 115 +- .../Storage/Mongo/MongoSchemaCollection.js | 192 +- .../Storage/Mongo/MongoStorageAdapter.js | 352 +- lib/Adapters/Storage/Mongo/MongoTransform.js | 664 +- .../Storage/Postgres/PostgresClient.js | 11 +- .../Storage/Postgres/PostgresConfigParser.js | 10 +- .../Postgres/PostgresStorageAdapter.js | 871 +- lib/Adapters/Storage/Postgres/sql/index.js | 13 +- lib/Adapters/Storage/StorageAdapter.js | 2 +- lib/Auth.js | 351 +- lib/ClientSDK.js | 12 +- lib/Config.js | 81 +- lib/Controllers/AdaptableController.js | 31 +- lib/Controllers/AnalyticsController.js | 34 +- lib/Controllers/CacheController.js | 27 +- lib/Controllers/DatabaseController.js | 514 +- lib/Controllers/FilesController.js | 51 +- lib/Controllers/HooksController.js | 140 +- lib/Controllers/LiveQueryController.js | 36 +- lib/Controllers/LoggerController.js | 78 +- lib/Controllers/PushController.js | 134 +- lib/Controllers/SchemaCache.js | 29 +- lib/Controllers/SchemaController.js | 955 +- lib/Controllers/UserController.js | 171 +- lib/Controllers/index.js | 135 +- lib/Controllers/types.js | 2 +- lib/LiveQuery/Client.js | 36 +- lib/LiveQuery/Id.js | 9 +- lib/LiveQuery/ParseCloudCodePublisher.js | 33 +- lib/LiveQuery/ParseLiveQueryServer.js | 583 +- lib/LiveQuery/ParsePubSub.js | 19 +- lib/LiveQuery/ParseWebSocketServer.js | 27 +- lib/LiveQuery/QueryTools.js | 117 +- lib/LiveQuery/RequestSchema.js | 190 +- lib/LiveQuery/SessionTokenCache.js | 55 +- lib/LiveQuery/Subscription.js | 25 +- lib/LiveQuery/equalObjects.js | 17 +- lib/Options/Definitions.js | 763 +- lib/Options/docs.js | 94 + lib/Options/index.js | 16 +- lib/Options/parsers.js | 18 +- lib/ParseMessageQueue.js | 17 +- lib/ParseServer.js | 249 +- lib/ParseServerRESTController.js | 55 +- lib/PromiseRouter.js | 95 +- lib/Push/PushQueue.js | 50 +- lib/Push/PushWorker.js | 107 +- lib/Push/utils.js | 52 +- lib/RestQuery.js | 366 +- lib/RestWrite.js | 627 +- lib/Routers/AggregateRouter.js | 132 +- lib/Routers/AnalyticsRouter.js | 18 +- lib/Routers/AudiencesRouter.js | 39 +- lib/Routers/ClassesRouter.js | 88 +- lib/Routers/CloudCodeRouter.js | 55 +- lib/Routers/ExportRouter.js | 122 +- lib/Routers/FeaturesRouter.js | 29 +- lib/Routers/FilesRouter.js | 140 +- lib/Routers/FunctionsRouter.js | 189 +- lib/Routers/GlobalConfigRouter.js | 66 +- lib/Routers/HooksRouter.js | 74 +- lib/Routers/IAPValidationRouter.js | 114 +- lib/Routers/ImportRouter.js | 90 +- lib/Routers/InstallationsRouter.js | 33 +- lib/Routers/LogsRouter.js | 33 +- lib/Routers/PublicAPIRouter.js | 120 +- lib/Routers/PurgeRouter.js | 43 +- lib/Routers/PushRouter.js | 37 +- lib/Routers/RolesRouter.js | 16 +- lib/Routers/SchemasRouter.js | 63 +- lib/Routers/SessionsRouter.js | 58 +- lib/Routers/UsersRouter.js | 241 +- lib/StatusHandler.js | 137 +- lib/TestUtils.js | 14 +- lib/batch.js | 59 +- lib/cache.js | 16 +- .../definitions/parse-live-query-server.js | 10 +- lib/cli/definitions/parse-server.js | 10 +- lib/cli/parse-live-query-server.js | 19 +- lib/cli/parse-server.js | 68 +- lib/cli/utils/commander.js | 68 +- lib/cli/utils/runner.js | 61 +- lib/cloud-code/HTTPResponse.js | 28 +- lib/cloud-code/Parse.Cloud.js | 240 +- lib/cloud-code/httpRequest.js | 210 +- lib/cryptoUtils.js | 23 +- lib/defaults.js | 36 +- lib/deprecated.js | 3 +- lib/index.js | 117 +- lib/logger.js | 26 +- lib/middlewares.js | 155 +- lib/password.js | 17 +- lib/request.js | 4 + lib/requiredParameter.js | 7 +- lib/rest.js | 87 +- lib/triggers.js | 290 +- lib/vendor/README.md | 6 +- lib/vendor/mongodbUrl.js | 439 +- package-lock.json | 7693 ++++++++--------- package.json | 74 +- release_docs.sh | 28 + resources/buildConfigDefinitions.js | 62 +- spec/.babelrc | 0 spec/.eslintrc.json | 3 +- spec/AccountLockoutPolicy.spec.js | 197 +- spec/AdaptableController.spec.js | 47 +- spec/AdapterLoader.spec.js | 90 +- spec/AggregateRouter.spec.js | 82 + spec/Analytics.spec.js | 102 +- spec/AudienceRouter.spec.js | 382 +- spec/Auth.spec.js | 176 +- spec/AuthenticationAdapters.spec.js | 562 +- spec/CLI.spec.js | 144 +- spec/CacheController.spec.js | 17 +- spec/Client.spec.js | 82 +- spec/ClientSDK.spec.js | 44 +- spec/CloudCode.spec.js | 1939 +++-- spec/CloudCodeLogger.spec.js | 281 +- spec/DatabaseController.spec.js | 58 +- spec/EmailVerificationToken.spec.js | 549 +- spec/EnableExpressErrorHandler.spec.js | 71 +- spec/EnableSingleSchemaCache.spec.js | 67 +- spec/EventEmitterPubSub.spec.js | 3 +- spec/FilesController.spec.js | 120 +- spec/GridFSBucketStorageAdapter.spec.js | 67 + spec/GridStoreAdapter.js | 87 - spec/GridStoreAdapter.spec.js | 99 + spec/HTTPRequest.spec.js | 267 +- spec/InMemoryCache.spec.js | 17 +- spec/InMemoryCacheAdapter.spec.js | 36 +- spec/InstallationsRouter.spec.js | 192 +- spec/JobSchedule.spec.js | 278 +- spec/Logger.spec.js | 40 +- spec/LoggerController.spec.js | 82 +- spec/LogsRouter.spec.js | 163 +- spec/Middlewares.spec.js | 118 +- spec/MockAdapter.js | 2 +- spec/MockEmailAdapter.js | 4 +- spec/MockEmailAdapterWithOptions.js | 10 +- spec/MockPushAdapter.js | 2 +- spec/MongoSchemaCollectionAdapter.spec.js | 79 +- spec/MongoStorageAdapter.spec.js | 117 +- spec/MongoTransform.spec.js | 374 +- spec/NullCacheAdapter.spec.js | 21 +- spec/OAuth1.spec.js | 151 +- spec/Parse.Push.spec.js | 586 +- spec/ParseACL.spec.js | 1901 ++-- spec/ParseAPI.spec.js | 1803 ++-- spec/ParseCloudCodePublisher.spec.js | 31 +- spec/ParseFile.spec.js | 917 +- spec/ParseGeoPoint.spec.js | 1184 ++- spec/ParseGlobalConfig.spec.js | 242 +- spec/ParseHooks.spec.js | 1044 ++- spec/ParseInstallation.spec.js | 1132 ++- spec/ParseLiveQueryServer.spec.js | 1270 ++- spec/ParseObject.spec.js | 3083 +++---- spec/ParsePolygon.spec.js | 589 +- spec/ParsePubSub.spec.js | 92 +- spec/ParseQuery.Aggregate.spec.js | 1345 +-- spec/ParseQuery.FullTextSearch.spec.js | 977 ++- spec/ParseQuery.spec.js | 5605 ++++++------ spec/ParseRelation.spec.js | 1225 +-- spec/ParseRole.spec.js | 934 +- spec/ParseServer.spec.js | 39 +- spec/ParseServerRESTController.spec.js | 292 +- spec/ParseSession.spec.js | 196 +- spec/ParseUser.spec.js | 5469 ++++++------ spec/ParseWebSocket.spec.js | 12 +- spec/ParseWebSocketServer.spec.js | 16 +- spec/PasswordPolicy.spec.js | 1970 +++-- spec/PointerPermissions.spec.js | 1229 ++- spec/PostgresConfigParser.spec.js | 29 +- spec/PostgresInitOptions.spec.js | 85 +- spec/PostgresStorageAdapter.spec.js | 43 +- spec/PromiseRouter.spec.js | 50 +- spec/PublicAPI.spec.js | 180 +- spec/PurchaseValidation.spec.js | 314 +- spec/PushController.spec.js | 1898 ++-- spec/PushQueue.spec.js | 42 +- spec/PushRouter.spec.js | 77 +- spec/PushWorker.spec.js | 534 +- spec/QueryTools.spec.js | 149 +- spec/ReadPreferenceOption.spec.js | 531 +- spec/RedisCacheAdapter.spec.js | 34 +- spec/RedisPubSub.spec.js | 13 +- spec/RestQuery.spec.js | 470 +- spec/RevocableSessionsUpgrade.spec.js | 164 +- spec/Schema.spec.js | 1849 ++-- spec/SchemaCache.spec.js | 67 +- spec/SessionTokenCache.spec.js | 39 +- spec/Subscription.spec.js | 69 +- spec/TwitterAuth.spec.js | 113 +- spec/Uniqueness.spec.js | 74 +- spec/UserController.spec.js | 87 +- spec/UserPII.spec.js | 524 +- spec/ValidationAndPasswordsReset.spec.js | 1088 +-- spec/VerifyUserPassword.spec.js | 857 +- spec/WinstonLoggerAdapter.spec.js | 124 +- spec/batch.spec.js | 28 +- spec/cloud/cloudCodeAbsoluteFile.js | 4 +- spec/cloud/cloudCodeRelativeFile.js | 4 +- spec/configs/CLIConfig.json | 0 spec/configs/CLIConfigApps.json | 13 +- spec/configs/CLIConfigFail.json | 0 spec/configs/CLIConfigFailTooManyApps.json | 24 +- spec/configs/CLIConfigUnknownArg.json | 0 spec/cryptoUtils.spec.js | 8 +- spec/features.spec.js | 16 +- spec/helper.js | 245 +- spec/index.spec.js | 449 +- spec/myoauth.js | 4 +- spec/parsers.spec.js | 24 +- spec/rest.spec.js | 845 +- spec/schemas.spec.js | 3152 ++++--- spec/support/CustomAuth.js | 5 +- spec/support/CustomAuthFunction.js | 7 +- spec/support/CustomMiddleware.js | 2 +- spec/support/jasmine.json | 8 +- spec/support/lorem.txt | 0 spec/testing-routes.js | 49 +- src/AccountLockout.js | 91 +- src/Adapters/AdapterLoader.js | 19 +- src/Adapters/Analytics/AnalyticsAdapter.js | 21 +- src/Adapters/Auth/AuthAdapter.js | 1 - src/Adapters/Auth/OAuth1Client.js | 172 +- src/Adapters/Auth/facebook.js | 64 +- src/Adapters/Auth/facebookaccountkit.js | 87 +- src/Adapters/Auth/github.js | 53 +- src/Adapters/Auth/google.js | 78 +- src/Adapters/Auth/httpsRequest.js | 41 + src/Adapters/Auth/index.js | 68 +- src/Adapters/Auth/instagram.js | 29 +- src/Adapters/Auth/janraincapture.js | 38 +- src/Adapters/Auth/janrainengage.js | 61 +- src/Adapters/Auth/linkedin.js | 58 +- src/Adapters/Auth/meetup.js | 51 +- src/Adapters/Auth/qq.js | 54 +- src/Adapters/Auth/spotify.js | 72 +- src/Adapters/Auth/twitter.js | 38 +- src/Adapters/Auth/vkontakte.js | 78 +- src/Adapters/Auth/wechat.js | 32 +- src/Adapters/Auth/weibo.js | 58 +- src/Adapters/Cache/CacheAdapter.js | 18 +- src/Adapters/Cache/InMemoryCache.js | 10 +- src/Adapters/Cache/InMemoryCacheAdapter.js | 5 +- src/Adapters/Cache/LRUCache.js | 10 +- src/Adapters/Cache/NullCacheAdapter.js | 5 +- src/Adapters/Cache/RedisCacheAdapter.js | 11 +- src/Adapters/Email/MailAdapter.js | 12 +- src/Adapters/Files/FilesAdapter.js | 28 +- src/Adapters/Files/GridFSBucketAdapter.js | 95 + src/Adapters/Files/GridStoreAdapter.js | 70 +- src/Adapters/Logger/LoggerAdapter.js | 26 +- src/Adapters/Logger/WinstonLogger.js | 69 +- src/Adapters/Logger/WinstonLoggerAdapter.js | 7 +- src/Adapters/MessageQueue/EventEmitterMQ.js | 12 +- src/Adapters/PubSub/EventEmitterPubSub.js | 12 +- src/Adapters/PubSub/PubSubAdapter.js | 49 + src/Adapters/PubSub/RedisPubSub.js | 58 +- src/Adapters/Push/PushAdapter.js | 14 +- src/Adapters/Storage/Mongo/MongoCollection.js | 101 +- .../Storage/Mongo/MongoSchemaCollection.js | 211 +- .../Storage/Mongo/MongoStorageAdapter.js | 620 +- src/Adapters/Storage/Mongo/MongoTransform.js | 1857 ++-- .../Storage/Postgres/PostgresClient.js | 1 - .../Storage/Postgres/PostgresConfigParser.js | 25 +- .../Postgres/PostgresStorageAdapter.js | 1384 +-- src/Adapters/Storage/Postgres/sql/index.js | 9 +- src/Adapters/Storage/StorageAdapter.js | 93 +- src/Auth.js | 383 +- src/ClientSDK.js | 12 +- src/Config.js | 167 +- src/Controllers/AdaptableController.js | 34 +- src/Controllers/AnalyticsController.js | 34 +- src/Controllers/CacheController.js | 4 +- src/Controllers/DatabaseController.js | 1123 ++- src/Controllers/FilesController.js | 22 +- src/Controllers/HooksController.js | 179 +- src/Controllers/LiveQueryController.js | 39 +- src/Controllers/LoggerController.js | 100 +- src/Controllers/PushController.js | 190 +- src/Controllers/SchemaCache.js | 29 +- src/Controllers/SchemaController.js | 1221 ++- src/Controllers/UserController.js | 231 +- src/Controllers/index.js | 217 +- src/Controllers/types.js | 30 +- src/LiveQuery/Client.js | 40 +- src/LiveQuery/ParseCloudCodePublisher.js | 16 +- src/LiveQuery/ParseLiveQueryServer.js | 577 +- src/LiveQuery/ParsePubSub.js | 28 +- src/LiveQuery/ParseWebSocketServer.js | 12 +- src/LiveQuery/QueryTools.js | 258 +- src/LiveQuery/RequestSchema.js | 202 +- src/LiveQuery/SessionTokenCache.js | 64 +- src/LiveQuery/Subscription.js | 10 +- src/LiveQuery/equalObjects.js | 4 +- src/Options/Definitions.js | 795 +- src/Options/docs.js | 92 + src/Options/index.js | 194 +- src/Options/parsers.js | 14 +- src/ParseMessageQueue.js | 24 +- src/ParseServer.js | 225 +- src/ParseServerRESTController.js | 89 +- src/PromiseRouter.js | 128 +- src/Push/PushQueue.js | 64 +- src/Push/PushWorker.js | 101 +- src/Push/utils.js | 88 +- src/RestQuery.js | 575 +- src/RestWrite.js | 1211 ++- src/Routers/AggregateRouter.js | 103 +- src/Routers/AnalyticsRouter.js | 5 +- src/Routers/AudiencesRouter.js | 77 +- src/Routers/ClassesRouter.js | 129 +- src/Routers/CloudCodeRouter.js | 118 +- src/Routers/FeaturesRouter.js | 109 +- src/Routers/FilesRouter.js | 161 +- src/Routers/FunctionsRouter.js | 171 +- src/Routers/GlobalConfigRouter.js | 46 +- src/Routers/HooksRouter.js | 143 +- src/Routers/IAPValidationRouter.js | 139 +- src/Routers/InstallationsRouter.js | 40 +- src/Routers/LogsRouter.js | 31 +- src/Routers/PublicAPIRouter.js | 236 +- src/Routers/PurgeRouter.js | 25 +- src/Routers/PushRouter.js | 74 +- src/Routers/RolesRouter.js | 21 +- src/Routers/SchemasRouter.js | 119 +- src/Routers/SessionsRouter.js | 93 +- src/Routers/UsersRouter.js | 321 +- src/StatusHandler.js | 165 +- src/TestUtils.js | 18 +- src/batch.js | 58 +- src/cache.js | 4 +- .../definitions/parse-live-query-server.js | 3 +- src/cli/definitions/parse-server.js | 3 +- src/cli/parse-live-query-server.js | 4 +- src/cli/parse-server.js | 59 +- src/cli/utils/commander.js | 32 +- src/cli/utils/runner.js | 16 +- src/cloud-code/HTTPResponse.js | 28 +- src/cloud-code/Parse.Cloud.js | 276 +- src/cloud-code/httpRequest.js | 171 +- src/cryptoUtils.js | 11 +- src/defaults.js | 24 +- src/deprecated.js | 2 +- src/index.js | 30 +- src/logger.js | 9 +- src/middlewares.js | 153 +- src/password.js | 6 +- src/request.js | 1 + src/requiredParameter.js | 4 +- src/rest.js | 315 +- src/triggers.js | 522 +- src/vendor/README.md | 6 +- src/vendor/mongodbUrl.js | 580 +- 410 files changed, 55917 insertions(+), 41215 deletions(-) create mode 100644 .github/ISSUE_TEMPLATE/---parse-server-3-0-0.md create mode 100644 .github/stale.yml create mode 100644 .prettierrc create mode 100644 3.0.0.md create mode 100644 jsdoc-conf.json create mode 100644 lib/Adapters/Auth/httpsRequest.js create mode 100644 lib/Adapters/Files/GridFSBucketAdapter.js create mode 100644 lib/Adapters/PubSub/PubSubAdapter.js create mode 100644 lib/Options/docs.js create mode 100644 lib/request.js create mode 100755 release_docs.sh mode change 100644 => 100755 spec/.babelrc mode change 100644 => 100755 spec/.eslintrc.json mode change 100644 => 100755 spec/AccountLockoutPolicy.spec.js mode change 100644 => 100755 spec/AdaptableController.spec.js mode change 100644 => 100755 spec/AdapterLoader.spec.js create mode 100755 spec/AggregateRouter.spec.js mode change 100644 => 100755 spec/Analytics.spec.js mode change 100644 => 100755 spec/AudienceRouter.spec.js mode change 100644 => 100755 spec/Auth.spec.js mode change 100644 => 100755 spec/AuthenticationAdapters.spec.js mode change 100644 => 100755 spec/CLI.spec.js mode change 100644 => 100755 spec/CacheController.spec.js mode change 100644 => 100755 spec/Client.spec.js mode change 100644 => 100755 spec/ClientSDK.spec.js mode change 100644 => 100755 spec/CloudCode.spec.js mode change 100644 => 100755 spec/CloudCodeLogger.spec.js mode change 100644 => 100755 spec/DatabaseController.spec.js mode change 100644 => 100755 spec/EmailVerificationToken.spec.js mode change 100644 => 100755 spec/EnableExpressErrorHandler.spec.js mode change 100644 => 100755 spec/EnableSingleSchemaCache.spec.js mode change 100644 => 100755 spec/EventEmitterPubSub.spec.js mode change 100644 => 100755 spec/FilesController.spec.js create mode 100755 spec/GridFSBucketStorageAdapter.spec.js delete mode 100644 spec/GridStoreAdapter.js create mode 100755 spec/GridStoreAdapter.spec.js mode change 100644 => 100755 spec/HTTPRequest.spec.js mode change 100644 => 100755 spec/InMemoryCache.spec.js mode change 100644 => 100755 spec/InMemoryCacheAdapter.spec.js mode change 100644 => 100755 spec/InstallationsRouter.spec.js mode change 100644 => 100755 spec/JobSchedule.spec.js mode change 100644 => 100755 spec/Logger.spec.js mode change 100644 => 100755 spec/LoggerController.spec.js mode change 100644 => 100755 spec/LogsRouter.spec.js mode change 100644 => 100755 spec/Middlewares.spec.js mode change 100644 => 100755 spec/MockAdapter.js mode change 100644 => 100755 spec/MockEmailAdapter.js mode change 100644 => 100755 spec/MockEmailAdapterWithOptions.js mode change 100644 => 100755 spec/MockPushAdapter.js mode change 100644 => 100755 spec/MongoSchemaCollectionAdapter.spec.js mode change 100644 => 100755 spec/MongoStorageAdapter.spec.js mode change 100644 => 100755 spec/MongoTransform.spec.js mode change 100644 => 100755 spec/NullCacheAdapter.spec.js mode change 100644 => 100755 spec/OAuth1.spec.js mode change 100644 => 100755 spec/Parse.Push.spec.js mode change 100644 => 100755 spec/ParseACL.spec.js mode change 100644 => 100755 spec/ParseAPI.spec.js mode change 100644 => 100755 spec/ParseCloudCodePublisher.spec.js mode change 100644 => 100755 spec/ParseFile.spec.js mode change 100644 => 100755 spec/ParseGeoPoint.spec.js mode change 100644 => 100755 spec/ParseGlobalConfig.spec.js mode change 100644 => 100755 spec/ParseHooks.spec.js mode change 100644 => 100755 spec/ParseInstallation.spec.js mode change 100644 => 100755 spec/ParseLiveQueryServer.spec.js mode change 100644 => 100755 spec/ParseObject.spec.js mode change 100644 => 100755 spec/ParsePolygon.spec.js mode change 100644 => 100755 spec/ParsePubSub.spec.js mode change 100644 => 100755 spec/ParseQuery.Aggregate.spec.js mode change 100644 => 100755 spec/ParseQuery.FullTextSearch.spec.js mode change 100644 => 100755 spec/ParseQuery.spec.js mode change 100644 => 100755 spec/ParseRelation.spec.js mode change 100644 => 100755 spec/ParseRole.spec.js mode change 100644 => 100755 spec/ParseServer.spec.js mode change 100644 => 100755 spec/ParseServerRESTController.spec.js mode change 100644 => 100755 spec/ParseSession.spec.js mode change 100644 => 100755 spec/ParseUser.spec.js mode change 100644 => 100755 spec/ParseWebSocket.spec.js mode change 100644 => 100755 spec/ParseWebSocketServer.spec.js mode change 100644 => 100755 spec/PasswordPolicy.spec.js mode change 100644 => 100755 spec/PointerPermissions.spec.js mode change 100644 => 100755 spec/PostgresConfigParser.spec.js mode change 100644 => 100755 spec/PostgresInitOptions.spec.js mode change 100644 => 100755 spec/PostgresStorageAdapter.spec.js mode change 100644 => 100755 spec/PromiseRouter.spec.js mode change 100644 => 100755 spec/PublicAPI.spec.js mode change 100644 => 100755 spec/PurchaseValidation.spec.js mode change 100644 => 100755 spec/PushController.spec.js mode change 100644 => 100755 spec/PushQueue.spec.js mode change 100644 => 100755 spec/PushRouter.spec.js mode change 100644 => 100755 spec/PushWorker.spec.js mode change 100644 => 100755 spec/QueryTools.spec.js mode change 100644 => 100755 spec/ReadPreferenceOption.spec.js mode change 100644 => 100755 spec/RedisCacheAdapter.spec.js mode change 100644 => 100755 spec/RedisPubSub.spec.js mode change 100644 => 100755 spec/RestQuery.spec.js mode change 100644 => 100755 spec/RevocableSessionsUpgrade.spec.js mode change 100644 => 100755 spec/Schema.spec.js mode change 100644 => 100755 spec/SchemaCache.spec.js mode change 100644 => 100755 spec/SessionTokenCache.spec.js mode change 100644 => 100755 spec/Subscription.spec.js mode change 100644 => 100755 spec/TwitterAuth.spec.js mode change 100644 => 100755 spec/Uniqueness.spec.js mode change 100644 => 100755 spec/UserController.spec.js mode change 100644 => 100755 spec/UserPII.spec.js mode change 100644 => 100755 spec/ValidationAndPasswordsReset.spec.js mode change 100644 => 100755 spec/VerifyUserPassword.spec.js mode change 100644 => 100755 spec/WinstonLoggerAdapter.spec.js mode change 100644 => 100755 spec/batch.spec.js mode change 100644 => 100755 spec/cloud/cloudCodeAbsoluteFile.js mode change 100644 => 100755 spec/cloud/cloudCodeRelativeFile.js mode change 100644 => 100755 spec/configs/CLIConfig.json mode change 100644 => 100755 spec/configs/CLIConfigApps.json mode change 100644 => 100755 spec/configs/CLIConfigFail.json mode change 100644 => 100755 spec/configs/CLIConfigFailTooManyApps.json mode change 100644 => 100755 spec/configs/CLIConfigUnknownArg.json mode change 100644 => 100755 spec/cryptoUtils.spec.js mode change 100644 => 100755 spec/features.spec.js mode change 100644 => 100755 spec/helper.js mode change 100644 => 100755 spec/index.spec.js mode change 100644 => 100755 spec/myoauth.js mode change 100644 => 100755 spec/parsers.spec.js mode change 100644 => 100755 spec/rest.spec.js mode change 100644 => 100755 spec/schemas.spec.js mode change 100644 => 100755 spec/support/CustomAuth.js mode change 100644 => 100755 spec/support/CustomAuthFunction.js mode change 100644 => 100755 spec/support/CustomMiddleware.js mode change 100644 => 100755 spec/support/jasmine.json mode change 100644 => 100755 spec/support/lorem.txt mode change 100644 => 100755 spec/testing-routes.js create mode 100644 src/Adapters/Auth/httpsRequest.js create mode 100644 src/Adapters/Files/GridFSBucketAdapter.js create mode 100644 src/Adapters/PubSub/PubSubAdapter.js create mode 100644 src/Options/docs.js create mode 100644 src/request.js diff --git a/.babelrc b/.babelrc index c8c8069f1d..1eb1208aa6 100644 --- a/.babelrc +++ b/.babelrc @@ -1,10 +1,10 @@ { "plugins": [ - "transform-flow-strip-types", - "transform-object-rest-spread" + "@babel/plugin-transform-flow-strip-types", + "@babel/plugin-proposal-object-rest-spread" ], "presets": [ - ["env", { + ["@babel/preset-env", { "targets": { "node": "8" } diff --git a/.eslintrc.json b/.eslintrc.json index 2a14b903f9..7c2b937b7c 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -14,7 +14,7 @@ "sourceType": "module" }, "rules": { - "indent": ["error", 2], + "indent": ["error", 2, { "SwitchCase": 1 }], "linebreak-style": ["error", "unix"], "no-trailing-spaces": 2, "eol-last": 2, diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md index 4de30ac7c8..6d82dd37ab 100644 --- a/.github/ISSUE_TEMPLATE.md +++ b/.github/ISSUE_TEMPLATE.md @@ -1,3 +1,5 @@ + ### Issue Description -Describe your issue in as much detail as possible. + ### Steps to reproduce -Please include a detailed list of steps that reproduce the issue. Include curl commands when applicable. + #### Expected Results -What you expected to happen. + #### Actual Outcome -What is happening instead. + ### Environment Setup diff --git a/.github/ISSUE_TEMPLATE/---parse-server-3-0-0.md b/.github/ISSUE_TEMPLATE/---parse-server-3-0-0.md new file mode 100644 index 0000000000..b74b3e67b0 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/---parse-server-3-0-0.md @@ -0,0 +1,54 @@ +--- +name: "\U0001F525 parse-server 3.0.0" +about: Report an issue while migrating to parse-server 3.0.0 + +--- + + + +# Before opening the issue please ensure that you have: + +- [ ] [Read the migration guide](https://github.com/parse-community/parse-server/blob/master/3.0.0.md) to parse-server 3.0.0 +- [ ] [Read the migration guide](https://github.com/parse-community/Parse-SDK-JS/blob/master/2.0.0.md) to Parse SDK JS 2.0.0 + +### Issue Description + + + +### Steps to reproduce + + + +### Expected Results + + + +### Actual Outcome + + + +### Environment Setup + +- **Server** + - parse-server version (Be specific! Don't say 'latest'.) : [FILL THIS OUT] + - Operating System: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, Heroku, Azure, Digital Ocean, etc): [FILL THIS OUT] + +- **Database** + - MongoDB version: [FILL THIS OUT] + - Storage engine: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, mLab, ObjectRocket, Digital Ocean, etc): [FILL THIS OUT] + +### Logs/Trace + + diff --git a/.github/ISSUE_TEMPLATE/---push-notifications.md b/.github/ISSUE_TEMPLATE/---push-notifications.md index 3466cb9c1d..78afe51052 100644 --- a/.github/ISSUE_TEMPLATE/---push-notifications.md +++ b/.github/ISSUE_TEMPLATE/---push-notifications.md @@ -4,4 +4,48 @@ about: Issues with setting up or delivering push notifications --- + + +### Issue Description + + + +### Push Configuration + +Please provide a copy of your `push` configuration here, obfuscating any sensitive part. + +### Environment Setup + +- **Server** + - parse-server version (Be specific! Don't say 'latest'.) : [FILL THIS OUT] + - Operating System: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, Heroku, Azure, Digital Ocean, etc): [FILL THIS OUT] + +- **Database** + - MongoDB version: [FILL THIS OUT] + - Storage engine: [FILL THIS OUT] + - Hardware: [FILL THIS OUT] + - Localhost or remote server? (AWS, mLab, ObjectRocket, Digital Ocean, etc): [FILL THIS OUT] + +### Logs/Trace + + diff --git a/.github/ISSUE_TEMPLATE/---report-an-issue.md b/.github/ISSUE_TEMPLATE/---report-an-issue.md index b5bdc244a4..b729f9525a 100644 --- a/.github/ISSUE_TEMPLATE/---report-an-issue.md +++ b/.github/ISSUE_TEMPLATE/---report-an-issue.md @@ -6,7 +6,11 @@ about: Report an issue on parse-server