parse-server 2.8.4 → 8.6.2

package/lib/LiveQuery/ParseLiveQueryServer.js

@@ -1,58 +1,44 @@
-'use strict';
+"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 }; }
+exports.ParseLiveQueryServer = void 0;
+var _tv = _interopRequireDefault(require("tv4"));
+var _node = _interopRequireDefault(require("parse/node"));
+var _Subscription = require("./Subscription");
+var _Client = require("./Client");
+var _ParseWebSocketServer = require("./ParseWebSocketServer");
+var _logger = _interopRequireDefault(require("../logger"));
+var _RequestSchema = _interopRequireDefault(require("./RequestSchema"));
+var _QueryTools = require("./QueryTools");
+var _ParsePubSub = require("./ParsePubSub");
+var _SchemaController = _interopRequireDefault(require("../Controllers/SchemaController"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _uuid = require("uuid");
+var _triggers = require("../triggers");
+var _Auth = require("../Auth");
+var _Controllers = require("../Controllers");
+var _lruCache = require("lru-cache");
+var _UsersRouter = _interopRequireDefault(require("../Routers/UsersRouter"));
+var _DatabaseController = _interopRequireDefault(require("../Controllers/DatabaseController"));
+var _util = require("util");
+var _deepcopy = _interopRequireDefault(require("deepcopy"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// @ts-ignore
 
 class ParseLiveQueryServer {
   // className -> (queryHash -> subscription)
-  constructor(server, config) {
+
+  // The subscriber we use to get object update from publisher
+
+  constructor(server, config = {}, parseServerConfig = {}) {
     this.server = server;
     this.clients = new Map();
     this.subscriptions = new Map();
-
-    config = config || {};
+    this.config = config;
+    config.appId = config.appId || _node.default.applicationId;
+    config.masterKey = config.masterKey || _node.default.masterKey;
 
     // Store keys, convert obj to map
     const keyPairs = config.keyPairs || {};
@@ -60,66 +46,106 @@ class ParseLiveQueryServer {
     for (const key of Object.keys(keyPairs)) {
       this.keyPairs.set(key, keyPairs[key]);
     }
-    _logger2.default.verbose('Support key pairs', this.keyPairs);
+    _logger.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);
-
+    _node.default.Object.disableSingleInstance();
+    const serverURL = config.serverURL || _node.default.serverURL;
+    _node.default.serverURL = serverURL;
+    _node.default.initialize(config.appId, _node.default.javaScriptKey, config.masterKey);
+
+    // The cache controller is a proper cache controller
+    // with access to User and Roles
+    this.cacheController = (0, _Controllers.getCacheController)(parseServerConfig);
+    config.cacheTimeout = config.cacheTimeout || 5 * 1000; // 5s
+
+    // This auth cache stores the promises for each auth resolution.
+    // The main benefit is to be able to reuse the same user / session token resolution.
+    this.authCache = new _lruCache.LRUCache({
+      max: 500,
+      // 500 concurrent
+      ttl: config.cacheTimeout
+    });
     // Initialize websocket server
-    this.parseWebSocketServer = new _ParseWebSocketServer.ParseWebSocketServer(server, parseWebsocket => this._onConnect(parseWebsocket), config.websocketTimeout);
-
-    // Initialize subscriber
+    this.parseWebSocketServer = new _ParseWebSocketServer.ParseWebSocketServer(server, parseWebsocket => this._onConnect(parseWebsocket), config);
     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);
+    if (!this.subscriber.connect) {
+      this.connect();
+    }
+  }
+  async connect() {
+    if (this.subscriber.isOpen) {
+      return;
+    }
+    if (typeof this.subscriber.connect === 'function') {
+      await Promise.resolve(this.subscriber.connect());
+    } else {
+      this.subscriber.isOpen = true;
+    }
+    this._createSubscribers();
+  }
+  async shutdown() {
+    if (this.subscriber.isOpen) {
+      await Promise.all([...[...this.clients.values()].map(client => client.parseWebSocket.ws.close()), this.parseWebSocketServer.close?.(), ...Array.from(this.subscriber.subscriptions?.keys() || []).map(key => this.subscriber.unsubscribe(key)), this.subscriber.close?.()]);
+    }
+    if (typeof this.subscriber.quit === 'function') {
+      try {
+        await this.subscriber.quit();
+      } catch (err) {
+        _logger.default.error('PubSubAdapter error on shutdown', {
+          error: err
+        });
+      }
+    } else {
+      this.subscriber.isOpen = false;
+    }
+  }
+  _createSubscribers() {
+    const messageRecieved = (channel, messageStr) => {
+      _logger.default.verbose('Subscribe message %j', messageStr);
       let message;
       try {
         message = JSON.parse(messageStr);
       } catch (e) {
-        _logger2.default.error('unable to parse message', messageStr, e);
+        _logger.default.error('unable to parse message', messageStr, e);
+        return;
+      }
+      if (channel === _node.default.applicationId + 'clearCache') {
+        this._clearCachedRoles(message.userId);
         return;
       }
       this._inflateParseObject(message);
-      if (channel === _node2.default.applicationId + 'afterSave') {
+      if (channel === _node.default.applicationId + 'afterSave') {
         this._onAfterSave(message);
-      } else if (channel === _node2.default.applicationId + 'afterDelete') {
+      } else if (channel === _node.default.applicationId + 'afterDelete') {
         this._onAfterDelete(message);
       } else {
-        _logger2.default.error('Get message %s from unknown channel %j', message, channel);
+        _logger.default.error('Get message %s from unknown channel %j', message, channel);
       }
-    });
-
-    // Initialize sessionToken cache
-    this.sessionTokenCache = new _SessionTokenCache.SessionTokenCache(config.cacheTimeout);
+    };
+    this.subscriber.on('message', (channel, messageStr) => messageRecieved(channel, messageStr));
+    for (const field of ['afterSave', 'afterDelete', 'clearCache']) {
+      const channel = `${_node.default.applicationId}${field}`;
+      this.subscriber.subscribe(channel, messageStr => messageRecieved(channel, messageStr));
+    }
   }
 
   // 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;
+    _UsersRouter.default.removeHiddenProperties(currentParseObject);
     let className = currentParseObject.className;
-    let parseObject = new _node2.default.Object(className);
+    let parseObject = new _node.default.Object(className);
     parseObject._finishFetch(currentParseObject);
     message.currentParseObject = parseObject;
     // Inflate original object
     const originalParseObject = message.originalParseObject;
     if (originalParseObject) {
+      _UsersRouter.default.removeHiddenProperties(originalParseObject);
       className = originalParseObject.className;
-      parseObject = new _node2.default.Object(className);
+      parseObject = new _node.default.Object(className);
       parseObject._finishFetch(originalParseObject);
       message.originalParseObject = parseObject;
     }
@@ -127,17 +153,16 @@ class ParseLiveQueryServer {
 
   // 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();
+  async _onAfterDelete(message) {
+    _logger.default.verbose(_node.default.applicationId + 'afterDelete is triggered');
+    let deletedParseObject = message.currentParseObject.toJSON();
+    const classLevelPermissions = message.classLevelPermissions;
     const className = deletedParseObject.className;
-    _logger2.default.verbose('ClassName: %j | ObjectId: %s', className, deletedParseObject.id);
-    _logger2.default.verbose('Current client number : %d', this.clients.size);
-
+    _logger.default.verbose('ClassName: %j | ObjectId: %s', className, deletedParseObject.id);
+    _logger.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);
+      _logger.default.debug('Can not find subscriptions under this class ' + className);
       return;
     }
     for (const subscription of classSubscriptions.values()) {
@@ -145,60 +170,93 @@ class ParseLiveQueryServer {
       if (!isSubscriptionMatched) {
         continue;
       }
-      for (const [clientId, requestIds] of _lodash2.default.entries(subscription.clientRequestIds)) {
+      for (const [clientId, requestIds] of _lodash.default.entries(subscription.clientRequestIds)) {
         const client = this.clients.get(clientId);
         if (typeof client === 'undefined') {
           continue;
         }
-        for (const requestId of requestIds) {
+        requestIds.forEach(async requestId => {
           const acl = message.currentParseObject.getACL();
-          // Check ACL
-          this._matchesACL(acl, client, requestId).then(isMatched => {
+          // Check CLP
+          const op = this._getCLPOperation(subscription.query);
+          let res = {};
+          try {
+            await this._matchesCLP(classLevelPermissions, message.currentParseObject, client, requestId, op);
+            const isMatched = await this._matchesACL(acl, client, requestId);
             if (!isMatched) {
               return null;
             }
+            res = {
+              event: 'delete',
+              sessionToken: client.sessionToken,
+              object: deletedParseObject,
+              clients: this.clients.size,
+              subscriptions: this.subscriptions.size,
+              useMasterKey: client.hasMasterKey,
+              installationId: client.installationId,
+              sendEvent: true
+            };
+            const trigger = (0, _triggers.getTrigger)(className, 'afterEvent', _node.default.applicationId);
+            if (trigger) {
+              const auth = await this.getAuthFromClient(client, requestId);
+              if (auth && auth.user) {
+                res.user = auth.user;
+              }
+              if (res.object) {
+                res.object = _node.default.Object.fromJSON(res.object);
+              }
+              await (0, _triggers.runTrigger)(trigger, `afterEvent.${className}`, res, auth);
+            }
+            if (!res.sendEvent) {
+              return;
+            }
+            if (res.object && typeof res.object.toJSON === 'function') {
+              deletedParseObject = (0, _triggers.toJSONwithObjects)(res.object, res.object.className || className);
+            }
+            await this._filterSensitiveData(classLevelPermissions, res, client, requestId, op, subscription.query);
             client.pushDelete(requestId, deletedParseObject);
-          }, error => {
-            _logger2.default.error('Matching ACL error : ', error);
-          });
-        }
+          } catch (e) {
+            const error = (0, _triggers.resolveError)(e);
+            _Client.Client.pushError(client.parseWebSocket, error.code, error.message, false, requestId);
+            _logger.default.error(`Failed running afterLiveQueryEvent on class ${className} for event ${res.event} with session ${res.sessionToken} with:\n Error: ` + JSON.stringify(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');
-
+  async _onAfterSave(message) {
+    _logger.default.verbose(_node.default.applicationId + 'afterSave is triggered');
     let originalParseObject = null;
     if (message.originalParseObject) {
       originalParseObject = message.originalParseObject.toJSON();
     }
-    const currentParseObject = message.currentParseObject.toJSON();
+    const classLevelPermissions = message.classLevelPermissions;
+    let 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);
-
+    _logger.default.verbose('ClassName: %s | ObjectId: %s', className, currentParseObject.id);
+    _logger.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);
+      _logger.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)) {
+      for (const [clientId, requestIds] of _lodash.default.entries(subscription.clientRequestIds)) {
         const client = this.clients.get(clientId);
         if (typeof client === 'undefined') {
           continue;
         }
-        for (const requestId of requestIds) {
+        requestIds.forEach(async requestId => {
           // 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);
+            originalACLCheckingPromise = Promise.resolve(false);
           } else {
             let originalACL;
             if (message.originalParseObject) {
@@ -209,60 +267,103 @@ class ParseLiveQueryServer {
           // Set current ParseObject ACL checking promise, if the object does not match
           // subscription, we do not need to check ACL
           let currentACLCheckingPromise;
+          let res = {};
           if (!isCurrentSubscriptionMatched) {
-            currentACLCheckingPromise = _node2.default.Promise.as(false);
+            currentACLCheckingPromise = Promise.resolve(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);
-
+          try {
+            const op = this._getCLPOperation(subscription.query);
+            await this._matchesCLP(classLevelPermissions, message.currentParseObject, client, requestId, op);
+            const [isOriginalMatched, isCurrentMatched] = await Promise.all([originalACLCheckingPromise, currentACLCheckingPromise]);
+            _logger.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';
+              type = 'update';
             } else if (isOriginalMatched && !isCurrentMatched) {
-              type = 'Leave';
+              type = 'leave';
             } else if (!isOriginalMatched && isCurrentMatched) {
               if (originalParseObject) {
-                type = 'Enter';
+                type = 'enter';
               } else {
-                type = 'Create';
+                type = 'create';
               }
             } else {
               return null;
             }
-            const functionName = 'push' + type;
-            client[functionName](requestId, currentParseObject);
-          }, error => {
-            _logger2.default.error('Matching ACL error : ', error);
-          });
-        }
+            const watchFieldsChanged = this._checkWatchFields(client, requestId, message);
+            if (!watchFieldsChanged && (type === 'update' || type === 'create')) {
+              return;
+            }
+            res = {
+              event: type,
+              sessionToken: client.sessionToken,
+              object: currentParseObject,
+              original: originalParseObject,
+              clients: this.clients.size,
+              subscriptions: this.subscriptions.size,
+              useMasterKey: client.hasMasterKey,
+              installationId: client.installationId,
+              sendEvent: true
+            };
+            const trigger = (0, _triggers.getTrigger)(className, 'afterEvent', _node.default.applicationId);
+            if (trigger) {
+              if (res.object) {
+                res.object = _node.default.Object.fromJSON(res.object);
+              }
+              if (res.original) {
+                res.original = _node.default.Object.fromJSON(res.original);
+              }
+              const auth = await this.getAuthFromClient(client, requestId);
+              if (auth && auth.user) {
+                res.user = auth.user;
+              }
+              await (0, _triggers.runTrigger)(trigger, `afterEvent.${className}`, res, auth);
+            }
+            if (!res.sendEvent) {
+              return;
+            }
+            if (res.object && typeof res.object.toJSON === 'function') {
+              currentParseObject = (0, _triggers.toJSONwithObjects)(res.object, res.object.className || className);
+            }
+            if (res.original && typeof res.original.toJSON === 'function') {
+              originalParseObject = (0, _triggers.toJSONwithObjects)(res.original, res.original.className || className);
+            }
+            await this._filterSensitiveData(classLevelPermissions, res, client, requestId, op, subscription.query);
+            const functionName = 'push' + res.event.charAt(0).toUpperCase() + res.event.slice(1);
+            if (client[functionName]) {
+              client[functionName](requestId, currentParseObject, originalParseObject);
+            }
+          } catch (e) {
+            const error = (0, _triggers.resolveError)(e);
+            _Client.Client.pushError(client.parseWebSocket, error.code, error.message, false, requestId);
+            _logger.default.error(`Failed running afterLiveQueryEvent on class ${className} for event ${res.event} with session ${res.sessionToken} with:\n Error: ` + JSON.stringify(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);
+          _logger.default.error('unable to parse request', request, e);
           return;
         }
       }
-      _logger2.default.verbose('Request: %j', request);
+      _logger.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);
+      if (!_tv.default.validate(request, _RequestSchema.default['general']) || !_tv.default.validate(request, _RequestSchema.default[request.op])) {
+        _Client.Client.pushError(parseWebsocket, 1, _tv.default.error.message);
+        _logger.default.error('Connect message error %s', _tv.default.error.message);
         return;
       }
-
       switch (request.op) {
         case 'connect':
           this._handleConnect(parseWebsocket, request);
@@ -278,12 +379,11 @@ class ParseLiveQueryServer {
           break;
         default:
           _Client.Client.pushError(parseWebsocket, 3, 'Get unknown operation');
-          _logger2.default.error('Get unknown operation', request.op);
+          _logger.default.error('Get unknown operation', request.op);
       }
     });
-
     parseWebsocket.on('disconnect', () => {
-      _logger2.default.info(`Client disconnect: ${parseWebsocket.clientId}`);
+      _logger.default.info(`Client disconnect: ${parseWebsocket.clientId}`);
       const clientId = parseWebsocket.clientId;
       if (!this.clients.has(clientId)) {
         (0, _triggers.runLiveQueryEventHandlers)({
@@ -292,7 +392,7 @@ class ParseLiveQueryServer {
           subscriptions: this.subscriptions.size,
           error: `Unable to find client ${clientId}`
         });
-        _logger2.default.error(`Can not find client ${clientId} on disconnect`);
+        _logger.default.error(`Can not find client ${clientId} on disconnect`);
         return;
       }
 
@@ -301,7 +401,7 @@ class ParseLiveQueryServer {
       this.clients.delete(clientId);
 
       // Delete client from subscriptions
-      for (const [requestId, subscriptionInfo] of _lodash2.default.entries(client.subscriptionInfos)) {
+      for (const [requestId, subscriptionInfo] of _lodash.default.entries(client.subscriptionInfos)) {
         const subscription = subscriptionInfo.subscription;
         subscription.deleteClientSubscription(clientId, requestId);
 
@@ -315,143 +415,282 @@ class ParseLiveQueryServer {
           this.subscriptions.delete(subscription.className);
         }
       }
-
-      _logger2.default.verbose('Current clients %d', this.clients.size);
-      _logger2.default.verbose('Current subscriptions %d', this.subscriptions.size);
+      _logger.default.verbose('Current clients %d', this.clients.size);
+      _logger.default.verbose('Current subscriptions %d', this.subscriptions.size);
       (0, _triggers.runLiveQueryEventHandlers)({
         event: 'ws_disconnect',
         clients: this.clients.size,
-        subscriptions: this.subscriptions.size
+        subscriptions: this.subscriptions.size,
+        useMasterKey: client.hasMasterKey,
+        installationId: client.installationId,
+        sessionToken: client.sessionToken
       });
     });
-
     (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);
+    return (0, _QueryTools.matchesQuery)((0, _deepcopy.default)(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);
+  async _clearCachedRoles(userId) {
+    try {
+      const validTokens = await new _node.default.Query(_node.default.Session).equalTo('user', _node.default.User.createWithoutData(userId)).find({
+        useMasterKey: true
+      });
+      await Promise.all(validTokens.map(async token => {
+        const sessionToken = token.get('sessionToken');
+        const authPromise = this.authCache.get(sessionToken);
+        if (!authPromise) {
+          return;
+        }
+        const [auth1, auth2] = await Promise.all([authPromise, (0, _Auth.getAuthForSessionToken)({
+          cacheController: this.cacheController,
+          sessionToken
+        })]);
+        auth1.auth?.clearRoleCache(sessionToken);
+        auth2.auth?.clearRoleCache(sessionToken);
+        this.authCache.delete(sessionToken);
+      }));
+    } catch (e) {
+      _logger.default.verbose(`Could not clear role cache. ${e}`);
     }
-    // Check subscription sessionToken matches ACL first
+  }
+  getAuthForSessionToken(sessionToken) {
+    if (!sessionToken) {
+      return Promise.resolve({});
+    }
+    const fromCache = this.authCache.get(sessionToken);
+    if (fromCache) {
+      return fromCache;
+    }
+    const authPromise = (0, _Auth.getAuthForSessionToken)({
+      cacheController: this.cacheController,
+      sessionToken: sessionToken
+    }).then(auth => {
+      return {
+        auth,
+        userId: auth && auth.user && auth.user.id
+      };
+    }).catch(error => {
+      // There was an error with the session token
+      const result = {};
+      if (error && error.code === _node.default.Error.INVALID_SESSION_TOKEN) {
+        result.error = error;
+        this.authCache.set(sessionToken, Promise.resolve(result), this.config.cacheTimeout);
+      } else {
+        this.authCache.delete(sessionToken);
+      }
+      return result;
+    });
+    this.authCache.set(sessionToken, authPromise);
+    return authPromise;
+  }
+  async _matchesCLP(classLevelPermissions, object, client, requestId, op) {
+    // try to match on user first, less expensive than with roles
     const subscriptionInfo = client.getSubscriptionInfo(requestId);
-    if (typeof subscriptionInfo === 'undefined') {
-      return _node2.default.Promise.as(false);
+    const aclGroup = ['*'];
+    let userId;
+    if (typeof subscriptionInfo !== 'undefined') {
+      const {
+        userId
+      } = await this.getAuthForSessionToken(subscriptionInfo.sessionToken);
+      if (userId) {
+        aclGroup.push(userId);
+      }
     }
-
-    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);
+    try {
+      await _SchemaController.default.validatePermission(classLevelPermissions, object.className, aclGroup, op);
+      return true;
+    } catch (e) {
+      _logger.default.verbose(`Failed matching CLP for ${object.id} ${userId} ${e}`);
+      return false;
+    }
+    // TODO: handle roles permissions
+    // Object.keys(classLevelPermissions).forEach((key) => {
+    //   const perm = classLevelPermissions[key];
+    //   Object.keys(perm).forEach((key) => {
+    //     if (key.indexOf('role'))
+    //   });
+    // })
+    // // it's rejected here, check the roles
+    // var rolesQuery = new Parse.Query(Parse.Role);
+    // rolesQuery.equalTo("users", user);
+    // return rolesQuery.find({useMasterKey:true});
+  }
+  async _filterSensitiveData(classLevelPermissions, res, client, requestId, op, query) {
+    const subscriptionInfo = client.getSubscriptionInfo(requestId);
+    const aclGroup = ['*'];
+    let clientAuth;
+    if (typeof subscriptionInfo !== 'undefined') {
+      const {
+        userId,
+        auth
+      } = await this.getAuthForSessionToken(subscriptionInfo.sessionToken);
+      if (userId) {
+        aclGroup.push(userId);
       }
+      clientAuth = auth;
+    }
+    const filter = obj => {
+      if (!obj) {
+        return;
+      }
+      let protectedFields = classLevelPermissions?.protectedFields || [];
+      if (!client.hasMasterKey && !Array.isArray(protectedFields)) {
+        protectedFields = (0, _Controllers.getDatabaseController)(this.config).addProtectedFields(classLevelPermissions, res.object.className, query, aclGroup, clientAuth);
+      }
+      return _DatabaseController.default.filterSensitiveData(client.hasMasterKey, false, aclGroup, clientAuth, op, classLevelPermissions, res.object.className, protectedFields, obj, query);
+    };
+    res.object = filter(res.object);
+    res.original = filter(res.original);
+  }
+  _getCLPOperation(query) {
+    return typeof query === 'object' && Object.keys(query).length == 1 && typeof query.objectId === 'string' ? 'get' : 'find';
+  }
+  async _verifyACL(acl, token) {
+    if (!token) {
+      return false;
+    }
+    const {
+      auth,
+      userId
+    } = await this.getAuthForSessionToken(token);
+
+    // Getting the session token failed
+    // This means that no additional auth is available
+    // At this point, just bail out as no additional visibility can be inferred.
+    if (!auth || !userId) {
+      return false;
+    }
+    const isSubscriptionSessionTokenMatched = acl.getReadAccess(userId);
+    if (isSubscriptionSessionTokenMatched) {
+      return 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);
+    // Check if the user has any roles that match the ACL
+    return Promise.resolve().then(async () => {
+      // 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 false;
+      }
+      const roleNames = await auth.getUserRoles();
+      // Finally, see if any of the user's roles allow them read access
+      for (const role of roleNames) {
+        // We use getReadAccess as `role` is in the form `role:roleName`
+        if (acl.getReadAccess(role)) {
+          return true;
         }
-
-        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);
+      return false;
+    }).catch(() => {
+      return false;
     });
   }
-
-  _handleConnect(parseWebsocket, request) {
+  async getAuthFromClient(client, requestId, sessionToken) {
+    const getSessionFromClient = () => {
+      const subscriptionInfo = client.getSubscriptionInfo(requestId);
+      if (typeof subscriptionInfo === 'undefined') {
+        return client.sessionToken;
+      }
+      return subscriptionInfo.sessionToken || client.sessionToken;
+    };
+    if (!sessionToken) {
+      sessionToken = getSessionFromClient();
+    }
+    if (!sessionToken) {
+      return;
+    }
+    const {
+      auth
+    } = await this.getAuthForSessionToken(sessionToken);
+    return auth;
+  }
+  _checkWatchFields(client, requestId, message) {
+    const subscriptionInfo = client.getSubscriptionInfo(requestId);
+    const watch = subscriptionInfo?.watch;
+    if (!watch) {
+      return true;
+    }
+    const object = message.currentParseObject;
+    const original = message.originalParseObject;
+    return watch.some(field => !(0, _util.isDeepStrictEqual)(object.get(field), original?.get(field)));
+  }
+  async _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 true;
+    }
+    // Check subscription sessionToken matches ACL first
+    const subscriptionInfo = client.getSubscriptionInfo(requestId);
+    if (typeof subscriptionInfo === 'undefined') {
+      return false;
+    }
+    const subscriptionToken = subscriptionInfo.sessionToken;
+    const clientSessionToken = client.sessionToken;
+    if (await this._verifyACL(acl, subscriptionToken)) {
+      return true;
+    }
+    if (await this._verifyACL(acl, clientSessionToken)) {
+      return true;
+    }
+    return false;
+  }
+  async _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');
+      _logger.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
-    });
+    const clientId = (0, _uuid.v4)();
+    const client = new _Client.Client(clientId, parseWebsocket, hasMasterKey, request.sessionToken, request.installationId);
+    try {
+      const req = {
+        client,
+        event: 'connect',
+        clients: this.clients.size,
+        subscriptions: this.subscriptions.size,
+        sessionToken: request.sessionToken,
+        useMasterKey: client.hasMasterKey,
+        installationId: request.installationId,
+        user: undefined
+      };
+      const trigger = (0, _triggers.getTrigger)('@Connect', 'beforeConnect', _node.default.applicationId);
+      if (trigger) {
+        const auth = await this.getAuthFromClient(client, request.requestId, req.sessionToken);
+        if (auth && auth.user) {
+          req.user = auth.user;
+        }
+        await (0, _triggers.runTrigger)(trigger, `beforeConnect.@Connect`, req, auth);
+      }
+      parseWebsocket.clientId = clientId;
+      this.clients.set(parseWebsocket.clientId, client);
+      _logger.default.info(`Create new client: ${parseWebsocket.clientId}`);
+      client.pushConnect();
+      (0, _triggers.runLiveQueryEventHandlers)(req);
+    } catch (e) {
+      const error = (0, _triggers.resolveError)(e);
+      _Client.Client.pushError(parseWebsocket, error.code, error.message, false);
+      _logger.default.error(`Failed running beforeConnect for session ${request.sessionToken} with:\n Error: ` + JSON.stringify(error));
+    }
   }
-
   _hasMasterKey(request, validKeyPairs) {
-    if (!validKeyPairs || validKeyPairs.size == 0 || !validKeyPairs.has("masterKey")) {
+    if (!validKeyPairs || validKeyPairs.size == 0 || !validKeyPairs.has('masterKey')) {
       return false;
     }
-    if (!request || !request.hasOwnProperty("masterKey")) {
+    if (!request || !Object.prototype.hasOwnProperty.call(request, 'masterKey')) {
       return false;
     }
-    return request.masterKey === validKeyPairs.get("masterKey");
+    return request.masterKey === validKeyPairs.get('masterKey');
   }
-
   _validateKeys(request, validKeyPairs) {
     if (!validKeyPairs || validKeyPairs.size == 0) {
       return true;
@@ -466,83 +705,119 @@ class ParseLiveQueryServer {
     }
     return isValid;
   }
-
-  _handleSubscribe(parseWebsocket, request) {
+  async _handleSubscribe(parseWebsocket, request) {
     // If we can not find this client, return error to client
-    if (!parseWebsocket.hasOwnProperty('clientId')) {
+    if (!Object.prototype.hasOwnProperty.call(parseWebsocket, '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');
+      _logger.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);
+    let authCalled = false;
+    try {
+      const trigger = (0, _triggers.getTrigger)(className, 'beforeSubscribe', _node.default.applicationId);
+      if (trigger) {
+        const auth = await this.getAuthFromClient(client, request.requestId, request.sessionToken);
+        authCalled = true;
+        if (auth && auth.user) {
+          request.user = auth.user;
+        }
+        const parseQuery = new _node.default.Query(className);
+        parseQuery.withJSON(request.query);
+        request.query = parseQuery;
+        await (0, _triggers.runTrigger)(trigger, `beforeSubscribe.${className}`, request, auth);
+        const query = request.query.toJSON();
+        request.query = query;
+      }
+      if (className === '_Session') {
+        if (!authCalled) {
+          const auth = await this.getAuthFromClient(client, request.requestId, request.sessionToken);
+          if (auth && auth.user) {
+            request.user = auth.user;
+          }
+        }
+        if (request.user) {
+          request.query.where.user = request.user.toPointer();
+        } else if (!request.master) {
+          _Client.Client.pushError(parseWebsocket, _node.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token', false, request.requestId);
+          return;
+        }
+      }
+      // Get subscription from subscriptions, create one if necessary
+      const subscriptionHash = (0, _QueryTools.queryHash)(request.query);
+      // Add className to subscriptions if necessary
 
-    // Add clientId to subscription
-    subscription.addClientSubscription(parseWebsocket.clientId, request.requestId);
+      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);
+      }
 
-    client.pushSubscribe(request.requestId);
+      // Add subscriptionInfo to client
+      const subscriptionInfo = {
+        subscription: subscription
+      };
+      // Add selected fields, sessionToken and installationId for this subscription if necessary
+      if (request.query.keys) {
+        subscriptionInfo.keys = Array.isArray(request.query.keys) ? request.query.keys : request.query.keys.split(',');
+      }
+      if (request.query.watch) {
+        subscriptionInfo.watch = request.query.watch;
+      }
+      if (request.sessionToken) {
+        subscriptionInfo.sessionToken = request.sessionToken;
+      }
+      client.addSubscriptionInfo(request.requestId, subscriptionInfo);
 
-    _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
-    });
+      // Add clientId to subscription
+      subscription.addClientSubscription(parseWebsocket.clientId, request.requestId);
+      client.pushSubscribe(request.requestId);
+      _logger.default.verbose(`Create client ${parseWebsocket.clientId} new subscription: ${request.requestId}`);
+      _logger.default.verbose('Current client number: %d', this.clients.size);
+      (0, _triggers.runLiveQueryEventHandlers)({
+        client,
+        event: 'subscribe',
+        clients: this.clients.size,
+        subscriptions: this.subscriptions.size,
+        sessionToken: request.sessionToken,
+        useMasterKey: client.hasMasterKey,
+        installationId: client.installationId
+      });
+    } catch (e) {
+      const error = (0, _triggers.resolveError)(e);
+      _Client.Client.pushError(parseWebsocket, error.code, error.message, false, request.requestId);
+      _logger.default.error(`Failed running beforeSubscribe on ${className} for session ${request.sessionToken} with:\n Error: ` + JSON.stringify(error));
+    }
   }
-
   _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')) {
+    if (!Object.prototype.hasOwnProperty.call(parseWebsocket, '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');
+      _logger.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);
+      _logger.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);
+      _logger.default.error('Can not find subscription with clientId ' + parseWebsocket.clientId + ' subscriptionId ' + requestId);
       return;
     }
 
@@ -562,20 +837,20 @@ class ParseLiveQueryServer {
       this.subscriptions.delete(className);
     }
     (0, _triggers.runLiveQueryEventHandlers)({
+      client,
       event: 'unsubscribe',
       clients: this.clients.size,
-      subscriptions: this.subscriptions.size
+      subscriptions: this.subscriptions.size,
+      sessionToken: subscriptionInfo.sessionToken,
+      useMasterKey: client.hasMasterKey,
+      installationId: client.installationId
     });
-
     if (!notifyClient) {
       return;
     }
-
     client.pushUnsubscribe(request.requestId);
-
-    _logger2.default.verbose(`Delete client: ${parseWebsocket.clientId} | subscription: ${request.requestId}`);
+    _logger.default.verbose(`Delete client: ${parseWebsocket.clientId} | subscription: ${request.requestId}`);
   }
 }
-
 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":"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","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"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_tv","_interopRequireDefault","require","_node","_Subscription","_Client","_ParseWebSocketServer","_logger","_RequestSchema","_QueryTools","_ParsePubSub","_SchemaController","_lodash","_uuid","_triggers","_Auth","_Controllers","_lruCache","_UsersRouter","_DatabaseController","_util","_deepcopy","e","__esModule","default","ParseLiveQueryServer","constructor","server","config","parseServerConfig","clients","Map","subscriptions","appId","Parse","applicationId","masterKey","keyPairs","key","Object","keys","set","logger","verbose","disableSingleInstance","serverURL","initialize","javaScriptKey","cacheController","getCacheController","cacheTimeout","authCache","LRU","max","ttl","parseWebSocketServer","ParseWebSocketServer","parseWebsocket","_onConnect","subscriber","ParsePubSub","createSubscriber","connect","isOpen","Promise","resolve","_createSubscribers","shutdown","all","values","map","client","parseWebSocket","ws","close","Array","from","unsubscribe","quit","err","error","messageRecieved","channel","messageStr","message","JSON","parse","_clearCachedRoles","userId","_inflateParseObject","_onAfterSave","_onAfterDelete","on","field","subscribe","currentParseObject","UserRouter","removeHiddenProperties","className","parseObject","_finishFetch","originalParseObject","deletedParseObject","toJSON","classLevelPermissions","id","size","classSubscriptions","get","debug","subscription","isSubscriptionMatched","_matchesSubscription","clientId","requestIds","_","entries","clientRequestIds","forEach","requestId","acl","getACL","op","_getCLPOperation","query","res","_matchesCLP","isMatched","_matchesACL","event","sessionToken","object","useMasterKey","hasMasterKey","installationId","sendEvent","trigger","getTrigger","auth","getAuthFromClient","user","fromJSON","runTrigger","toJSONwithObjects","_filterSensitiveData","pushDelete","resolveError","Client","pushError","code","stringify","isOriginalSubscriptionMatched","isCurrentSubscriptionMatched","originalACLCheckingPromise","originalACL","currentACLCheckingPromise","currentACL","isOriginalMatched","isCurrentMatched","hash","type","watchFieldsChanged","_checkWatchFields","original","functionName","charAt","toUpperCase","slice","request","tv4","validate","RequestSchema","_handleConnect","_handleSubscribe","_handleUpdateSubscription","_handleUnsubscribe","info","has","runLiveQueryEventHandlers","delete","subscriptionInfo","subscriptionInfos","deleteClientSubscription","hasSubscribingClient","matchesQuery","deepcopy","validTokens","Query","Session","equalTo","User","createWithoutData","find","token","authPromise","auth1","auth2","getAuthForSessionToken","clearRoleCache","fromCache","then","catch","result","Error","INVALID_SESSION_TOKEN","getSubscriptionInfo","aclGroup","push","SchemaController","validatePermission","clientAuth","filter","obj","protectedFields","isArray","getDatabaseController","addProtectedFields","DatabaseController","filterSensitiveData","length","objectId","_verifyACL","isSubscriptionSessionTokenMatched","getReadAccess","acl_has_roles","permissionsById","some","startsWith","roleNames","getUserRoles","role","getSessionFromClient","watch","isDeepStrictEqual","getPublicReadAccess","subscriptionToken","clientSessionToken","_validateKeys","_hasMasterKey","uuidv4","req","undefined","pushConnect","validKeyPairs","prototype","hasOwnProperty","call","isValid","secret","authCalled","parseQuery","withJSON","where","toPointer","master","subscriptionHash","queryHash","Subscription","split","addSubscriptionInfo","addClientSubscription","pushSubscribe","notifyClient","deleteSubscriptionInfo","pushUnsubscribe","exports"],"sources":["../../src/LiveQuery/ParseLiveQueryServer.ts"],"sourcesContent":["import tv4 from 'tv4';\nimport Parse from 'parse/node';\nimport { Subscription } from './Subscription';\nimport { Client } from './Client';\nimport { ParseWebSocketServer } from './ParseWebSocketServer';\n// @ts-ignore\nimport logger from '../logger';\nimport RequestSchema from './RequestSchema';\nimport { matchesQuery, queryHash } from './QueryTools';\nimport { ParsePubSub } from './ParsePubSub';\nimport SchemaController from '../Controllers/SchemaController';\nimport _ from 'lodash';\nimport { v4 as uuidv4 } from 'uuid';\nimport {\n  runLiveQueryEventHandlers,\n  getTrigger,\n  runTrigger,\n  resolveError,\n  toJSONwithObjects,\n} from '../triggers';\nimport { getAuthForSessionToken, Auth } from '../Auth';\nimport { getCacheController, getDatabaseController } from '../Controllers';\nimport { LRUCache as LRU } from 'lru-cache';\nimport UserRouter from '../Routers/UsersRouter';\nimport DatabaseController from '../Controllers/DatabaseController';\nimport { isDeepStrictEqual } from 'util';\nimport deepcopy from 'deepcopy';\n\nclass ParseLiveQueryServer {\n  server: any;\n  config: any;\n  clients: Map<string, any>;\n  // className -> (queryHash -> subscription)\n  subscriptions: Map<string, any>;\n  parseWebSocketServer: any;\n  keyPairs: any;\n  // The subscriber we use to get object update from publisher\n  subscriber: any;\n  authCache: any;\n  cacheController: any;\n\n  constructor(server: any, config: any = {}, parseServerConfig: any = {}) {\n    this.server = server;\n    this.clients = new Map();\n    this.subscriptions = new Map();\n    this.config = config;\n\n    config.appId = config.appId || Parse.applicationId;\n    config.masterKey = config.masterKey || Parse.masterKey;\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    const serverURL = config.serverURL || Parse.serverURL;\n    Parse.serverURL = serverURL;\n    Parse.initialize(config.appId, Parse.javaScriptKey, config.masterKey);\n\n    // The cache controller is a proper cache controller\n    // with access to User and Roles\n    this.cacheController = getCacheController(parseServerConfig);\n\n    config.cacheTimeout = config.cacheTimeout || 5 * 1000; // 5s\n\n    // This auth cache stores the promises for each auth resolution.\n    // The main benefit is to be able to reuse the same user / session token resolution.\n    this.authCache = new LRU({\n      max: 500, // 500 concurrent\n      ttl: config.cacheTimeout,\n    });\n    // Initialize websocket server\n    this.parseWebSocketServer = new ParseWebSocketServer(\n      server,\n      parseWebsocket => this._onConnect(parseWebsocket),\n      config\n    );\n    this.subscriber = ParsePubSub.createSubscriber(config);\n    if (!this.subscriber.connect) {\n      this.connect();\n    }\n  }\n\n  async connect() {\n    if (this.subscriber.isOpen) {\n      return;\n    }\n    if (typeof this.subscriber.connect === 'function') {\n      await Promise.resolve(this.subscriber.connect());\n    } else {\n      this.subscriber.isOpen = true;\n    }\n    this._createSubscribers();\n  }\n\n  async shutdown() {\n    if (this.subscriber.isOpen) {\n      await Promise.all([\n        ...[...this.clients.values()].map(client => client.parseWebSocket.ws.close()),\n        this.parseWebSocketServer.close?.(),\n        ...Array.from(this.subscriber.subscriptions?.keys() || []).map(key =>\n          this.subscriber.unsubscribe(key)\n        ),\n        this.subscriber.close?.(),\n      ]);\n    }\n    if (typeof this.subscriber.quit === 'function') {\n      try {\n        await this.subscriber.quit();\n      } catch (err) {\n        logger.error('PubSubAdapter error on shutdown', { error: err });\n      }\n    } else {\n      this.subscriber.isOpen = false;\n    }\n  }\n\n  _createSubscribers() {\n    const messageRecieved = (channel, messageStr) => {\n      logger.verbose('Subscribe message %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      if (channel === Parse.applicationId + 'clearCache') {\n        this._clearCachedRoles(message.userId);\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    this.subscriber.on('message', (channel, messageStr) => messageRecieved(channel, messageStr));\n    for (const field of ['afterSave', 'afterDelete', 'clearCache']) {\n      const channel = `${Parse.applicationId}${field}`;\n      this.subscriber.subscribe(channel, messageStr => messageRecieved(channel, messageStr));\n    }\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    UserRouter.removeHiddenProperties(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      UserRouter.removeHiddenProperties(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  async _onAfterDelete(message: any): Promise<void> {\n    logger.verbose(Parse.applicationId + 'afterDelete is triggered');\n\n    let deletedParseObject = message.currentParseObject.toJSON();\n    const classLevelPermissions = message.classLevelPermissions;\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\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        requestIds.forEach(async requestId => {\n          const acl = message.currentParseObject.getACL();\n          // Check CLP\n          const op = this._getCLPOperation(subscription.query);\n          let res: any = {};\n          try {\n            await this._matchesCLP(\n              classLevelPermissions,\n              message.currentParseObject,\n              client,\n              requestId,\n              op\n            );\n            const isMatched = await this._matchesACL(acl, client, requestId);\n            if (!isMatched) {\n              return null;\n            }\n            res = {\n              event: 'delete',\n              sessionToken: client.sessionToken,\n              object: deletedParseObject,\n              clients: this.clients.size,\n              subscriptions: this.subscriptions.size,\n              useMasterKey: client.hasMasterKey,\n              installationId: client.installationId,\n              sendEvent: true,\n            };\n            const trigger = getTrigger(className, 'afterEvent', Parse.applicationId);\n            if (trigger) {\n              const auth = await this.getAuthFromClient(client, requestId);\n              if (auth && auth.user) {\n                res.user = auth.user;\n              }\n              if (res.object) {\n                res.object = Parse.Object.fromJSON(res.object);\n              }\n              await runTrigger(trigger, `afterEvent.${className}`, res, auth);\n            }\n            if (!res.sendEvent) {\n              return;\n            }\n            if (res.object && typeof res.object.toJSON === 'function') {\n              deletedParseObject = toJSONwithObjects(res.object, res.object.className || className);\n            }\n            await this._filterSensitiveData(\n              classLevelPermissions,\n              res,\n              client,\n              requestId,\n              op,\n              subscription.query\n            );\n            client.pushDelete(requestId, deletedParseObject);\n          } catch (e) {\n            const error = resolveError(e);\n            Client.pushError(client.parseWebSocket, error.code, error.message, false, requestId);\n            logger.error(\n              `Failed running afterLiveQueryEvent on class ${className} for event ${res.event} with session ${res.sessionToken} with:\\n Error: ` +\n                JSON.stringify(error)\n            );\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  async _onAfterSave(message: any): Promise<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 classLevelPermissions = message.classLevelPermissions;\n    let 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(\n        originalParseObject,\n        subscription\n      );\n      const isCurrentSubscriptionMatched = this._matchesSubscription(\n        currentParseObject,\n        subscription\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        requestIds.forEach(async requestId => {\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 = Promise.resolve(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          let res: any = {};\n          if (!isCurrentSubscriptionMatched) {\n            currentACLCheckingPromise = Promise.resolve(false);\n          } else {\n            const currentACL = message.currentParseObject.getACL();\n            currentACLCheckingPromise = this._matchesACL(currentACL, client, requestId);\n          }\n          try {\n            const op = this._getCLPOperation(subscription.query);\n            await this._matchesCLP(\n              classLevelPermissions,\n              message.currentParseObject,\n              client,\n              requestId,\n              op\n            );\n            const [isOriginalMatched, isCurrentMatched] = await Promise.all([\n              originalACLCheckingPromise,\n              currentACLCheckingPromise,\n            ]);\n            logger.verbose(\n              '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            // 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 watchFieldsChanged = this._checkWatchFields(client, requestId, message);\n            if (!watchFieldsChanged && (type === 'update' || type === 'create')) {\n              return;\n            }\n            res = {\n              event: type,\n              sessionToken: client.sessionToken,\n              object: currentParseObject,\n              original: originalParseObject,\n              clients: this.clients.size,\n              subscriptions: this.subscriptions.size,\n              useMasterKey: client.hasMasterKey,\n              installationId: client.installationId,\n              sendEvent: true,\n            };\n            const trigger = getTrigger(className, 'afterEvent', Parse.applicationId);\n            if (trigger) {\n              if (res.object) {\n                res.object = Parse.Object.fromJSON(res.object);\n              }\n              if (res.original) {\n                res.original = Parse.Object.fromJSON(res.original);\n              }\n              const auth = await this.getAuthFromClient(client, requestId);\n              if (auth && auth.user) {\n                res.user = auth.user;\n              }\n              await runTrigger(trigger, `afterEvent.${className}`, res, auth);\n            }\n            if (!res.sendEvent) {\n              return;\n            }\n            if (res.object && typeof res.object.toJSON === 'function') {\n              currentParseObject = toJSONwithObjects(res.object, res.object.className || className);\n            }\n            if (res.original && typeof res.original.toJSON === 'function') {\n              originalParseObject = toJSONwithObjects(\n                res.original,\n                res.original.className || className\n              );\n            }\n            await this._filterSensitiveData(\n              classLevelPermissions,\n              res,\n              client,\n              requestId,\n              op,\n              subscription.query\n            );\n            const functionName = 'push' + res.event.charAt(0).toUpperCase() + res.event.slice(1);\n            if (client[functionName]) {\n              client[functionName](requestId, currentParseObject, originalParseObject);\n            }\n          } catch (e) {\n            const error = resolveError(e);\n            Client.pushError(client.parseWebSocket, error.code, error.message, false, requestId);\n            logger.error(\n              `Failed running afterLiveQueryEvent on class ${className} for event ${res.event} with session ${res.sessionToken} with:\\n Error: ` +\n                JSON.stringify(error)\n            );\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 (\n        !tv4.validate(request, RequestSchema['general']) ||\n        !tv4.validate(request, RequestSchema[request.op])\n      ) {\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        useMasterKey: client.hasMasterKey,\n        installationId: client.installationId,\n        sessionToken: client.sessionToken,\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(deepcopy(parseObject), subscription.query);\n  }\n\n  async _clearCachedRoles(userId: string) {\n    try {\n      const validTokens = await new Parse.Query(Parse.Session)\n        .equalTo('user', Parse.User.createWithoutData(userId))\n        .find({ useMasterKey: true });\n      await Promise.all(\n        validTokens.map(async token => {\n          const sessionToken = token.get('sessionToken');\n          const authPromise = this.authCache.get(sessionToken);\n          if (!authPromise) {\n            return;\n          }\n          const [auth1, auth2] = await Promise.all([\n            authPromise,\n            getAuthForSessionToken({ cacheController: this.cacheController, sessionToken }),\n          ]);\n          auth1.auth?.clearRoleCache(sessionToken);\n          auth2.auth?.clearRoleCache(sessionToken);\n          this.authCache.delete(sessionToken);\n        })\n      );\n    } catch (e) {\n      logger.verbose(`Could not clear role cache. ${e}`);\n    }\n  }\n\n  getAuthForSessionToken(sessionToken?: string): Promise<{ auth?: Auth, userId?: string }> {\n    if (!sessionToken) {\n      return Promise.resolve({});\n    }\n    const fromCache = this.authCache.get(sessionToken);\n    if (fromCache) {\n      return fromCache;\n    }\n    const authPromise = getAuthForSessionToken({\n      cacheController: this.cacheController,\n      sessionToken: sessionToken,\n    })\n      .then(auth => {\n        return { auth, userId: auth && auth.user && auth.user.id };\n      })\n      .catch(error => {\n        // There was an error with the session token\n        const result: any = {};\n        if (error && error.code === Parse.Error.INVALID_SESSION_TOKEN) {\n          result.error = error;\n          this.authCache.set(sessionToken, Promise.resolve(result), this.config.cacheTimeout);\n        } else {\n          this.authCache.delete(sessionToken);\n        }\n        return result;\n      });\n    this.authCache.set(sessionToken, authPromise);\n    return authPromise;\n  }\n\n  async _matchesCLP(\n    classLevelPermissions?: any,\n    object?: any,\n    client?: any,\n    requestId?: number,\n    op?: string\n  ): Promise<any> {\n    // try to match on user first, less expensive than with roles\n    const subscriptionInfo = client.getSubscriptionInfo(requestId);\n    const aclGroup = ['*'];\n    let userId;\n    if (typeof subscriptionInfo !== 'undefined') {\n      const { userId } = await this.getAuthForSessionToken(subscriptionInfo.sessionToken);\n      if (userId) {\n        aclGroup.push(userId);\n      }\n    }\n    try {\n      await SchemaController.validatePermission(\n        classLevelPermissions,\n        object.className,\n        aclGroup,\n        op\n      );\n      return true;\n    } catch (e) {\n      logger.verbose(`Failed matching CLP for ${object.id} ${userId} ${e}`);\n      return false;\n    }\n    // TODO: handle roles permissions\n    // Object.keys(classLevelPermissions).forEach((key) => {\n    //   const perm = classLevelPermissions[key];\n    //   Object.keys(perm).forEach((key) => {\n    //     if (key.indexOf('role'))\n    //   });\n    // })\n    // // it's rejected here, check the roles\n    // var rolesQuery = new Parse.Query(Parse.Role);\n    // rolesQuery.equalTo(\"users\", user);\n    // return rolesQuery.find({useMasterKey:true});\n  }\n\n  async _filterSensitiveData(\n    classLevelPermissions?: any,\n    res?: any,\n    client?: any,\n    requestId?: number,\n    op?: string,\n    query?: any\n  ) {\n    const subscriptionInfo = client.getSubscriptionInfo(requestId);\n    const aclGroup = ['*'];\n    let clientAuth;\n    if (typeof subscriptionInfo !== 'undefined') {\n      const { userId, auth } = await this.getAuthForSessionToken(subscriptionInfo.sessionToken);\n      if (userId) {\n        aclGroup.push(userId);\n      }\n      clientAuth = auth;\n    }\n    const filter = obj => {\n      if (!obj) {\n        return;\n      }\n      let protectedFields = classLevelPermissions?.protectedFields || [];\n      if (!client.hasMasterKey && !Array.isArray(protectedFields)) {\n        protectedFields = getDatabaseController(this.config).addProtectedFields(\n          classLevelPermissions,\n          res.object.className,\n          query,\n          aclGroup,\n          clientAuth\n        );\n      }\n      return DatabaseController.filterSensitiveData(\n        client.hasMasterKey,\n        false,\n        aclGroup,\n        clientAuth,\n        op,\n        classLevelPermissions,\n        res.object.className,\n        protectedFields,\n        obj,\n        query\n      );\n    };\n    res.object = filter(res.object);\n    res.original = filter(res.original);\n  }\n\n  _getCLPOperation(query: any) {\n    return typeof query === 'object' &&\n      Object.keys(query).length == 1 &&\n      typeof query.objectId === 'string'\n      ? 'get'\n      : 'find';\n  }\n\n  async _verifyACL(acl: any, token: string) {\n    if (!token) {\n      return false;\n    }\n\n    const { auth, userId } = await this.getAuthForSessionToken(token);\n\n    // Getting the session token failed\n    // This means that no additional auth is available\n    // At this point, just bail out as no additional visibility can be inferred.\n    if (!auth || !userId) {\n      return false;\n    }\n    const isSubscriptionSessionTokenMatched = acl.getReadAccess(userId);\n    if (isSubscriptionSessionTokenMatched) {\n      return true;\n    }\n\n    // Check if the user has any roles that match the ACL\n    return Promise.resolve()\n      .then(async () => {\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 false;\n        }\n        const roleNames = await auth.getUserRoles();\n        // Finally, see if any of the user's roles allow them read access\n        for (const role of roleNames) {\n          // We use getReadAccess as `role` is in the form `role:roleName`\n          if (acl.getReadAccess(role)) {\n            return true;\n          }\n        }\n        return false;\n      })\n      .catch(() => {\n        return false;\n      });\n  }\n\n  async getAuthFromClient(client: any, requestId: number, sessionToken?: string) {\n    const getSessionFromClient = () => {\n      const subscriptionInfo = client.getSubscriptionInfo(requestId);\n      if (typeof subscriptionInfo === 'undefined') {\n        return client.sessionToken;\n      }\n      return subscriptionInfo.sessionToken || client.sessionToken;\n    };\n    if (!sessionToken) {\n      sessionToken = getSessionFromClient();\n    }\n    if (!sessionToken) {\n      return;\n    }\n    const { auth } = await this.getAuthForSessionToken(sessionToken);\n    return auth;\n  }\n\n  _checkWatchFields(client: any, requestId: any, message: any) {\n    const subscriptionInfo = client.getSubscriptionInfo(requestId);\n    const watch = subscriptionInfo?.watch;\n    if (!watch) {\n      return true;\n    }\n    const object = message.currentParseObject;\n    const original = message.originalParseObject;\n    return watch.some(field => !isDeepStrictEqual(object.get(field), original?.get(field)));\n  }\n\n  async _matchesACL(acl: any, client: any, requestId: number): Promise<boolean> {\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 true;\n    }\n    // Check subscription sessionToken matches ACL first\n    const subscriptionInfo = client.getSubscriptionInfo(requestId);\n    if (typeof subscriptionInfo === 'undefined') {\n      return false;\n    }\n\n    const subscriptionToken = subscriptionInfo.sessionToken;\n    const clientSessionToken = client.sessionToken;\n\n    if (await this._verifyACL(acl, subscriptionToken)) {\n      return true;\n    }\n\n    if (await this._verifyACL(acl, clientSessionToken)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  async _handleConnect(parseWebsocket: any, request: any): Promise<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 = uuidv4();\n    const client = new Client(\n      clientId,\n      parseWebsocket,\n      hasMasterKey,\n      request.sessionToken,\n      request.installationId\n    );\n    try {\n      const req = {\n        client,\n        event: 'connect',\n        clients: this.clients.size,\n        subscriptions: this.subscriptions.size,\n        sessionToken: request.sessionToken,\n        useMasterKey: client.hasMasterKey,\n        installationId: request.installationId,\n        user: undefined,\n      };\n      const trigger = getTrigger('@Connect', 'beforeConnect', Parse.applicationId);\n      if (trigger) {\n        const auth = await this.getAuthFromClient(client, request.requestId, req.sessionToken);\n        if (auth && auth.user) {\n          req.user = auth.user;\n        }\n        await runTrigger(trigger, `beforeConnect.@Connect`, req, auth);\n      }\n      parseWebsocket.clientId = clientId;\n      this.clients.set(parseWebsocket.clientId, client);\n      logger.info(`Create new client: ${parseWebsocket.clientId}`);\n      client.pushConnect();\n      runLiveQueryEventHandlers(req);\n    } catch (e) {\n      const error = resolveError(e);\n      Client.pushError(parseWebsocket, error.code, error.message, false);\n      logger.error(\n        `Failed running beforeConnect for session ${request.sessionToken} with:\\n Error: ` +\n          JSON.stringify(error)\n      );\n    }\n  }\n\n  _hasMasterKey(request: any, validKeyPairs: any): boolean {\n    if (!validKeyPairs || validKeyPairs.size == 0 || !validKeyPairs.has('masterKey')) {\n      return false;\n    }\n    if (!request || !Object.prototype.hasOwnProperty.call(request, '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  async _handleSubscribe(parseWebsocket: any, request: any): Promise<any> {\n    // If we can not find this client, return error to client\n    if (!Object.prototype.hasOwnProperty.call(parseWebsocket, 'clientId')) {\n      Client.pushError(\n        parseWebsocket,\n        2,\n        'Can not find this client, make sure you connect to server before subscribing'\n      );\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    const className = request.query.className;\n    let authCalled = false;\n    try {\n      const trigger = getTrigger(className, 'beforeSubscribe', Parse.applicationId);\n      if (trigger) {\n        const auth = await this.getAuthFromClient(client, request.requestId, request.sessionToken);\n        authCalled = true;\n        if (auth && auth.user) {\n          request.user = auth.user;\n        }\n\n        const parseQuery = new Parse.Query(className);\n        parseQuery.withJSON(request.query);\n        request.query = parseQuery;\n        await runTrigger(trigger, `beforeSubscribe.${className}`, request, auth);\n\n        const query = request.query.toJSON();\n        request.query = query;\n      }\n\n      if (className === '_Session') {\n        if (!authCalled) {\n          const auth = await this.getAuthFromClient(\n            client,\n            request.requestId,\n            request.sessionToken\n          );\n          if (auth && auth.user) {\n            request.user = auth.user;\n          }\n        }\n        if (request.user) {\n          request.query.where.user = request.user.toPointer();\n        } else if (!request.master) {\n          Client.pushError(\n            parseWebsocket,\n            Parse.Error.INVALID_SESSION_TOKEN,\n            'Invalid session token',\n            false,\n            request.requestId\n          );\n          return;\n        }\n      }\n      // Get subscription from subscriptions, create one if necessary\n      const subscriptionHash = queryHash(request.query);\n      // Add className to subscriptions if necessary\n\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: any = {\n        subscription: subscription,\n      };\n      // Add selected fields, sessionToken and installationId for this subscription if necessary\n      if (request.query.keys) {\n        subscriptionInfo.keys = Array.isArray(request.query.keys)\n          ? request.query.keys\n          : request.query.keys.split(',');\n      }\n      if (request.query.watch) {\n        subscriptionInfo.watch = request.query.watch;\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(\n        `Create client ${parseWebsocket.clientId} new subscription: ${request.requestId}`\n      );\n      logger.verbose('Current client number: %d', this.clients.size);\n      runLiveQueryEventHandlers({\n        client,\n        event: 'subscribe',\n        clients: this.clients.size,\n        subscriptions: this.subscriptions.size,\n        sessionToken: request.sessionToken,\n        useMasterKey: client.hasMasterKey,\n        installationId: client.installationId,\n      });\n    } catch (e) {\n      const error = resolveError(e);\n      Client.pushError(parseWebsocket, error.code, error.message, false, request.requestId);\n      logger.error(\n        `Failed running beforeSubscribe on ${className} for session ${request.sessionToken} with:\\n Error: ` +\n          JSON.stringify(error)\n      );\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: boolean = true): any {\n    // If we can not find this client, return error to client\n    if (!Object.prototype.hasOwnProperty.call(parseWebsocket, 'clientId')) {\n      Client.pushError(\n        parseWebsocket,\n        2,\n        'Can not find this client, make sure you connect to server before unsubscribing'\n      );\n      logger.error(\n        'Can not find this client, make sure you connect to server before unsubscribing'\n      );\n      return;\n    }\n    const requestId = request.requestId;\n    const client = this.clients.get(parseWebsocket.clientId);\n    if (typeof client === 'undefined') {\n      Client.pushError(\n        parseWebsocket,\n        2,\n        'Cannot find client with clientId ' +\n          parseWebsocket.clientId +\n          '. Make sure you connect to live query server before unsubscribing.'\n      );\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(\n        parseWebsocket,\n        2,\n        'Cannot find subscription with clientId ' +\n          parseWebsocket.clientId +\n          ' subscriptionId ' +\n          requestId +\n          '. Make sure you subscribe to live query server before unsubscribing.'\n      );\n      logger.error(\n        'Can not find subscription with clientId ' +\n          parseWebsocket.clientId +\n          ' subscriptionId ' +\n          requestId\n      );\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      client,\n      event: 'unsubscribe',\n      clients: this.clients.size,\n      subscriptions: this.subscriptions.size,\n      sessionToken: subscriptionInfo.sessionToken,\n      useMasterKey: client.hasMasterKey,\n      installationId: client.installationId,\n    });\n\n    if (!notifyClient) {\n      return;\n    }\n\n    client.pushUnsubscribe(request.requestId);\n\n    logger.verbose(\n      `Delete client: ${parseWebsocket.clientId} | subscription: ${request.requestId}`\n    );\n  }\n}\n\nexport { ParseLiveQueryServer };\n"],"mappings":"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","ignoreList":[]}