@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/ParseServerRESTController.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParseServerRESTController = ParseServerRESTController;
+exports.default = void 0;
+var _RESTController = _interopRequireDefault(require("parse/lib/node/RESTController"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const Config = require('./Config');
+const Auth = require('./Auth');
+const Parse = require('parse/node');
+function getSessionToken(options) {
+  if (options && typeof options.sessionToken === 'string') {
+    return Promise.resolve(options.sessionToken);
+  }
+  return Promise.resolve(null);
+}
+function getAuth(options = {}, config) {
+  const installationId = options.installationId || 'cloud';
+  if (options.useMasterKey) {
+    return Promise.resolve(new Auth.Auth({
+      config,
+      isMaster: true,
+      installationId
+    }));
+  }
+  return getSessionToken(options).then(sessionToken => {
+    if (sessionToken) {
+      options.sessionToken = sessionToken;
+      return Auth.getAuthForSessionToken({
+        config,
+        sessionToken: sessionToken,
+        installationId
+      });
+    } else {
+      return Promise.resolve(new Auth.Auth({
+        config,
+        installationId
+      }));
+    }
+  });
+}
+function ParseServerRESTController(applicationId, router) {
+  function handleRequest(method, path, data = {}, options = {}, config) {
+    // Store the arguments, for later use if internal fails
+    const args = arguments;
+    if (!config) {
+      config = Config.get(applicationId);
+    }
+    const serverURL = new URL(config.serverURL);
+    if (path.indexOf(serverURL.pathname) === 0) {
+      path = path.slice(serverURL.pathname.length, path.length);
+    }
+    if (path[0] !== '/') {
+      path = '/' + path;
+    }
+    if (path === '/batch') {
+      const batch = transactionRetries => {
+        let initialPromise = Promise.resolve();
+        if (data.transaction === true) {
+          initialPromise = config.database.createTransactionalSession();
+        }
+        return initialPromise.then(() => {
+          const promises = data.requests.map(request => {
+            return handleRequest(request.method, request.path, request.body, options, config).then(response => {
+              if (options.returnStatus) {
+                const status = response._status;
+                const headers = response._headers;
+                delete response._status;
+                delete response._headers;
+                return {
+                  success: response,
+                  _status: status,
+                  _headers: headers
+                };
+              }
+              return {
+                success: response
+              };
+            }, error => {
+              return {
+                error: {
+                  code: error.code,
+                  error: error.message
+                }
+              };
+            });
+          });
+          return Promise.all(promises).then(result => {
+            if (data.transaction === true) {
+              if (result.find(resultItem => typeof resultItem.error === 'object')) {
+                return config.database.abortTransactionalSession().then(() => {
+                  return Promise.reject(result);
+                });
+              } else {
+                return config.database.commitTransactionalSession().then(() => {
+                  return result;
+                });
+              }
+            } else {
+              return result;
+            }
+          }).catch(error => {
+            if (error && error.find(errorItem => typeof errorItem.error === 'object' && errorItem.error.code === 251) && transactionRetries > 0) {
+              return batch(transactionRetries - 1);
+            }
+            throw error;
+          });
+        });
+      };
+      return batch(5);
+    }
+    let query;
+    if (method === 'GET') {
+      query = data;
+    }
+    return new Promise((resolve, reject) => {
+      let requestContext;
+      try {
+        requestContext = structuredClone(options.context || {});
+      } catch (error) {
+        reject(new Parse.Error(Parse.Error.INVALID_VALUE, `Context contains non-cloneable values: ${error.message}`));
+        return;
+      }
+      getAuth(options, config).then(auth => {
+        const request = {
+          body: data,
+          config,
+          auth,
+          info: {
+            applicationId: applicationId,
+            sessionToken: options.sessionToken,
+            installationId: options.installationId,
+            context: requestContext
+          },
+          query
+        };
+        return Promise.resolve().then(() => {
+          return router.tryRouteRequest(method, path, request);
+        }).then(resp => {
+          const {
+            response,
+            status,
+            headers = {}
+          } = resp;
+          if (options.returnStatus) {
+            resolve({
+              ...response,
+              _status: status,
+              _headers: headers
+            });
+          } else {
+            resolve(response);
+          }
+        }, err => {
+          if (err instanceof Parse.Error && err.code == Parse.Error.INVALID_JSON && err.message == `cannot route ${method} ${path}`) {
+            _RESTController.default.request.apply(null, args).then(resolve, reject);
+          } else {
+            reject(err);
+          }
+        });
+      }, reject);
+    });
+  }
+  return {
+    request: handleRequest,
+    ajax: _RESTController.default.ajax,
+    handleError: _RESTController.default.handleError
+  };
+}
+var _default = exports.default = ParseServerRESTController;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_RESTController","_interopRequireDefault","require","e","__esModule","default","Config","Auth","Parse","getSessionToken","options","sessionToken","Promise","resolve","getAuth","config","installationId","useMasterKey","isMaster","then","getAuthForSessionToken","ParseServerRESTController","applicationId","router","handleRequest","method","path","data","args","arguments","get","serverURL","URL","indexOf","pathname","slice","length","batch","transactionRetries","initialPromise","transaction","database","createTransactionalSession","promises","requests","map","request","body","response","returnStatus","status","_status","headers","_headers","success","error","code","message","all","result","find","resultItem","abortTransactionalSession","reject","commitTransactionalSession","catch","errorItem","query","requestContext","structuredClone","context","Error","INVALID_VALUE","auth","info","tryRouteRequest","resp","err","INVALID_JSON","RESTController","apply","ajax","handleError","_default","exports"],"sources":["../src/ParseServerRESTController.js"],"sourcesContent":["const Config = require('./Config');\nconst Auth = require('./Auth');\nimport RESTController from 'parse/lib/node/RESTController';\nconst Parse = require('parse/node');\n\nfunction getSessionToken(options) {\n  if (options && typeof options.sessionToken === 'string') {\n    return Promise.resolve(options.sessionToken);\n  }\n  return Promise.resolve(null);\n}\n\nfunction getAuth(options = {}, config) {\n  const installationId = options.installationId || 'cloud';\n  if (options.useMasterKey) {\n    return Promise.resolve(new Auth.Auth({ config, isMaster: true, installationId }));\n  }\n  return getSessionToken(options).then(sessionToken => {\n    if (sessionToken) {\n      options.sessionToken = sessionToken;\n      return Auth.getAuthForSessionToken({\n        config,\n        sessionToken: sessionToken,\n        installationId,\n      });\n    } else {\n      return Promise.resolve(new Auth.Auth({ config, installationId }));\n    }\n  });\n}\n\nfunction ParseServerRESTController(applicationId, router) {\n  function handleRequest(method, path, data = {}, options = {}, config) {\n    // Store the arguments, for later use if internal fails\n    const args = arguments;\n\n    if (!config) {\n      config = Config.get(applicationId);\n    }\n    const serverURL = new URL(config.serverURL);\n    if (path.indexOf(serverURL.pathname) === 0) {\n      path = path.slice(serverURL.pathname.length, path.length);\n    }\n\n    if (path[0] !== '/') {\n      path = '/' + path;\n    }\n\n    if (path === '/batch') {\n      const batch = transactionRetries => {\n        let initialPromise = Promise.resolve();\n        if (data.transaction === true) {\n          initialPromise = config.database.createTransactionalSession();\n        }\n        return initialPromise.then(() => {\n          const promises = data.requests.map(request => {\n            return handleRequest(request.method, request.path, request.body, options, config).then(\n              response => {\n                if (options.returnStatus) {\n                  const status = response._status;\n                  const headers = response._headers;\n                  delete response._status;\n                  delete response._headers;\n                  return { success: response, _status: status, _headers: headers };\n                }\n                return { success: response };\n              },\n              error => {\n                return {\n                  error: { code: error.code, error: error.message },\n                };\n              }\n            );\n          });\n          return Promise.all(promises)\n            .then(result => {\n              if (data.transaction === true) {\n                if (result.find(resultItem => typeof resultItem.error === 'object')) {\n                  return config.database.abortTransactionalSession().then(() => {\n                    return Promise.reject(result);\n                  });\n                } else {\n                  return config.database.commitTransactionalSession().then(() => {\n                    return result;\n                  });\n                }\n              } else {\n                return result;\n              }\n            })\n            .catch(error => {\n              if (\n                error &&\n                error.find(\n                  errorItem => typeof errorItem.error === 'object' && errorItem.error.code === 251\n                ) &&\n                transactionRetries > 0\n              ) {\n                return batch(transactionRetries - 1);\n              }\n              throw error;\n            });\n        });\n      };\n      return batch(5);\n    }\n\n    let query;\n    if (method === 'GET') {\n      query = data;\n    }\n\n    return new Promise((resolve, reject) => {\n      let requestContext;\n      try {\n        requestContext = structuredClone(options.context || {});\n      } catch (error) {\n        reject(\n          new Parse.Error(\n            Parse.Error.INVALID_VALUE,\n            `Context contains non-cloneable values: ${error.message}`\n          )\n        );\n        return;\n      }\n      getAuth(options, config).then(auth => {\n        const request = {\n          body: data,\n          config,\n          auth,\n          info: {\n            applicationId: applicationId,\n            sessionToken: options.sessionToken,\n            installationId: options.installationId,\n            context: requestContext,\n          },\n          query,\n        };\n        return Promise.resolve()\n          .then(() => {\n            return router.tryRouteRequest(method, path, request);\n          })\n          .then(\n            resp => {\n              const { response, status, headers = {} } = resp;\n              if (options.returnStatus) {\n                resolve({ ...response, _status: status, _headers: headers });\n              } else {\n                resolve(response);\n              }\n            },\n            err => {\n              if (\n                err instanceof Parse.Error &&\n                err.code == Parse.Error.INVALID_JSON &&\n                err.message == `cannot route ${method} ${path}`\n              ) {\n                RESTController.request.apply(null, args).then(resolve, reject);\n              } else {\n                reject(err);\n              }\n            }\n          );\n      }, reject);\n    });\n  }\n\n  return {\n    request: handleRequest,\n    ajax: RESTController.ajax,\n    handleError: RESTController.handleError,\n  };\n}\n\nexport default ParseServerRESTController;\nexport { ParseServerRESTController };\n"],"mappings":"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","ignoreList":[]}

package/lib/PromiseRouter.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+var _express = _interopRequireDefault(require("express"));
+var _logger = _interopRequireDefault(require("./logger"));
+var _util = require("util");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// A router that is based on promises rather than req/res/next.
+// This is intended to replace the use of express.Router to handle
+// subsections of the API surface.
+// This will make it easier to have methods like 'batch' that
+// themselves use our routing information, without disturbing express
+// components that external developers may be modifying.
+
+const Layer = require('router/lib/layer');
+function validateParameter(key, value) {
+  if (key == 'className') {
+    if (value.match(/_?[A-Za-z][A-Za-z_0-9]*/)) {
+      return value;
+    }
+  } else if (key == 'objectId') {
+    if (value.match(/[A-Za-z0-9]+/)) {
+      return value;
+    }
+  } else {
+    return value;
+  }
+}
+class PromiseRouter {
+  // Each entry should be an object with:
+  // path: the path to route, in express format
+  // method: the HTTP method that this route handles.
+  //   Must be one of: POST, GET, PUT, DELETE
+  // handler: a function that takes request, and returns a promise.
+  //   Successful handlers should resolve to an object with fields:
+  //     status: optional. the http status code. defaults to 200
+  //     response: a json object with the content of the response
+  //     location: optional. a location header
+  constructor(routes = [], appId) {
+    this.routes = routes;
+    this.appId = appId;
+    this.mountRoutes();
+  }
+
+  // Leave the opportunity to
+  // subclasses to mount their routes by overriding
+  mountRoutes() {}
+
+  // Merge the routes into this one
+  merge(router) {
+    for (var route of router.routes) {
+      this.routes.push(route);
+    }
+  }
+  route(method, path, ...handlers) {
+    switch (method) {
+      case 'POST':
+      case 'GET':
+      case 'PUT':
+      case 'DELETE':
+        break;
+      default:
+        throw 'cannot route method: ' + method;
+    }
+    let handler = handlers[0];
+    if (handlers.length > 1) {
+      handler = function (req) {
+        return handlers.reduce((promise, handler) => {
+          return promise.then(() => {
+            return handler(req);
+          });
+        }, Promise.resolve());
+      };
+    }
+    this.routes.push({
+      path: path,
+      method: method,
+      handler: handler,
+      layer: new Layer(path, null, handler)
+    });
+  }
+
+  // Returns an object with:
+  //   handler: the handler that should deal with this request
+  //   params: any :-params that got parsed from the path
+  // Returns undefined if there is no match.
+  match(method, path) {
+    for (var route of this.routes) {
+      if (route.method != method) {
+        continue;
+      }
+      const layer = route.layer || new Layer(route.path, null, route.handler);
+      const match = layer.match(path);
+      if (match) {
+        const params = layer.params;
+        Object.keys(params).forEach(key => {
+          params[key] = validateParameter(key, params[key]);
+        });
+        return {
+          params: params,
+          handler: route.handler
+        };
+      }
+    }
+  }
+
+  // Mount the routes on this router onto an express app (or express router)
+  mountOnto(expressApp) {
+    this.routes.forEach(route => {
+      const method = route.method.toLowerCase();
+      const handler = makeExpressHandler(this.appId, route.handler);
+      expressApp[method].call(expressApp, route.path, handler);
+    });
+    return expressApp;
+  }
+  expressRouter() {
+    return this.mountOnto(_express.default.Router());
+  }
+  tryRouteRequest(method, path, request) {
+    var match = this.match(method, path);
+    if (!match) {
+      throw new _node.default.Error(_node.default.Error.INVALID_JSON, 'cannot route ' + method + ' ' + path);
+    }
+    request.params = match.params;
+    return new Promise((resolve, reject) => {
+      match.handler(request).then(resolve, reject);
+    });
+  }
+}
+
+// A helper function to make an express handler out of a a promise
+// handler.
+// Express handlers should never throw; if a promise handler throws we
+// just treat it like it resolved to an error.
+exports.default = PromiseRouter;
+function makeExpressHandler(appId, promiseHandler) {
+  return function (req, res, next) {
+    try {
+      const url = maskSensitiveUrl(req);
+      const body = Object.assign({}, req.body);
+      const method = req.method;
+      const headers = req.headers;
+      _logger.default.logRequest({
+        method,
+        url,
+        headers,
+        body
+      });
+      promiseHandler(req).then(result => {
+        if (!result.response && !result.location && !result.text) {
+          _logger.default.error('the handler did not include a "response" or a "location" field');
+          throw 'control should not get here';
+        }
+        _logger.default.logResponse({
+          method,
+          url,
+          result
+        });
+        var status = result.status || 200;
+        res.status(status);
+        if (result.headers) {
+          Object.keys(result.headers).forEach(header => {
+            res.set(header, result.headers[header]);
+          });
+        }
+        if (result.text) {
+          res.send(result.text);
+          return;
+        }
+        if (result.location) {
+          res.set('Location', result.location);
+          // Override the default expressjs response
+          // as it double encodes %encoded chars in URL
+          if (!result.response) {
+            res.send('Found. Redirecting to ' + result.location);
+            return;
+          }
+        }
+        res.json(result.response);
+      }, error => {
+        next(error);
+      }).catch(e => {
+        _logger.default.error(`Error generating response. ${(0, _util.inspect)(e)}`, {
+          error: e
+        });
+        next(e);
+      });
+    } catch (e) {
+      _logger.default.error(`Error handling request: ${(0, _util.inspect)(e)}`, {
+        error: e
+      });
+      next(e);
+    }
+  };
+}
+function maskSensitiveUrl(req) {
+  let maskUrl = req.originalUrl.toString();
+  const shouldMaskUrl = req.method === 'GET' && req.originalUrl.includes('/login') && !req.originalUrl.includes('classes');
+  if (shouldMaskUrl) {
+    maskUrl = _logger.default.maskSensitiveUrl(maskUrl);
+  }
+  return maskUrl;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_express","_logger","_util","e","__esModule","default","Layer","validateParameter","key","value","match","PromiseRouter","constructor","routes","appId","mountRoutes","merge","router","route","push","method","path","handlers","handler","length","req","reduce","promise","then","Promise","resolve","layer","params","Object","keys","forEach","mountOnto","expressApp","toLowerCase","makeExpressHandler","call","expressRouter","express","Router","tryRouteRequest","request","Parse","Error","INVALID_JSON","reject","exports","promiseHandler","res","next","url","maskSensitiveUrl","body","assign","headers","log","logRequest","result","response","location","text","error","logResponse","status","header","set","send","json","catch","inspect","maskUrl","originalUrl","toString","shouldMaskUrl","includes"],"sources":["../src/PromiseRouter.js"],"sourcesContent":["// A router that is based on promises rather than req/res/next.\n// This is intended to replace the use of express.Router to handle\n// subsections of the API surface.\n// This will make it easier to have methods like 'batch' that\n// themselves use our routing information, without disturbing express\n// components that external developers may be modifying.\n\nimport Parse from 'parse/node';\nimport express from 'express';\nimport log from './logger';\nimport { inspect } from 'util';\nconst Layer = require('router/lib/layer');\n\nfunction validateParameter(key, value) {\n  if (key == 'className') {\n    if (value.match(/_?[A-Za-z][A-Za-z_0-9]*/)) {\n      return value;\n    }\n  } else if (key == 'objectId') {\n    if (value.match(/[A-Za-z0-9]+/)) {\n      return value;\n    }\n  } else {\n    return value;\n  }\n}\n\nexport default class PromiseRouter {\n  // Each entry should be an object with:\n  // path: the path to route, in express format\n  // method: the HTTP method that this route handles.\n  //   Must be one of: POST, GET, PUT, DELETE\n  // handler: a function that takes request, and returns a promise.\n  //   Successful handlers should resolve to an object with fields:\n  //     status: optional. the http status code. defaults to 200\n  //     response: a json object with the content of the response\n  //     location: optional. a location header\n  constructor(routes = [], appId) {\n    this.routes = routes;\n    this.appId = appId;\n    this.mountRoutes();\n  }\n\n  // Leave the opportunity to\n  // subclasses to mount their routes by overriding\n  mountRoutes() {}\n\n  // Merge the routes into this one\n  merge(router) {\n    for (var route of router.routes) {\n      this.routes.push(route);\n    }\n  }\n\n  route(method, path, ...handlers) {\n    switch (method) {\n      case 'POST':\n      case 'GET':\n      case 'PUT':\n      case 'DELETE':\n        break;\n      default:\n        throw 'cannot route method: ' + method;\n    }\n\n    let handler = handlers[0];\n\n    if (handlers.length > 1) {\n      handler = function (req) {\n        return handlers.reduce((promise, handler) => {\n          return promise.then(() => {\n            return handler(req);\n          });\n        }, Promise.resolve());\n      };\n    }\n\n    this.routes.push({\n      path: path,\n      method: method,\n      handler: handler,\n      layer: new Layer(path, null, handler),\n    });\n  }\n\n  // Returns an object with:\n  //   handler: the handler that should deal with this request\n  //   params: any :-params that got parsed from the path\n  // Returns undefined if there is no match.\n  match(method, path) {\n    for (var route of this.routes) {\n      if (route.method != method) {\n        continue;\n      }\n      const layer = route.layer || new Layer(route.path, null, route.handler);\n      const match = layer.match(path);\n      if (match) {\n        const params = layer.params;\n        Object.keys(params).forEach(key => {\n          params[key] = validateParameter(key, params[key]);\n        });\n        return { params: params, handler: route.handler };\n      }\n    }\n  }\n\n  // Mount the routes on this router onto an express app (or express router)\n  mountOnto(expressApp) {\n    this.routes.forEach(route => {\n      const method = route.method.toLowerCase();\n      const handler = makeExpressHandler(this.appId, route.handler);\n      expressApp[method].call(expressApp, route.path, handler);\n    });\n    return expressApp;\n  }\n\n  expressRouter() {\n    return this.mountOnto(express.Router());\n  }\n\n  tryRouteRequest(method, path, request) {\n    var match = this.match(method, path);\n    if (!match) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot route ' + method + ' ' + path);\n    }\n    request.params = match.params;\n    return new Promise((resolve, reject) => {\n      match.handler(request).then(resolve, reject);\n    });\n  }\n}\n\n// A helper function to make an express handler out of a a promise\n// handler.\n// Express handlers should never throw; if a promise handler throws we\n// just treat it like it resolved to an error.\nfunction makeExpressHandler(appId, promiseHandler) {\n  return function (req, res, next) {\n    try {\n      const url = maskSensitiveUrl(req);\n      const body = Object.assign({}, req.body);\n      const method = req.method;\n      const headers = req.headers;\n      log.logRequest({\n        method,\n        url,\n        headers,\n        body,\n      });\n      promiseHandler(req)\n        .then(\n          result => {\n            if (!result.response && !result.location && !result.text) {\n              log.error('the handler did not include a \"response\" or a \"location\" field');\n              throw 'control should not get here';\n            }\n\n            log.logResponse({ method, url, result });\n\n            var status = result.status || 200;\n            res.status(status);\n\n            if (result.headers) {\n              Object.keys(result.headers).forEach(header => {\n                res.set(header, result.headers[header]);\n              });\n            }\n\n            if (result.text) {\n              res.send(result.text);\n              return;\n            }\n\n            if (result.location) {\n              res.set('Location', result.location);\n              // Override the default expressjs response\n              // as it double encodes %encoded chars in URL\n              if (!result.response) {\n                res.send('Found. Redirecting to ' + result.location);\n                return;\n              }\n            }\n            res.json(result.response);\n          },\n          error => {\n            next(error);\n          }\n        )\n        .catch(e => {\n          log.error(`Error generating response. ${inspect(e)}`, { error: e });\n          next(e);\n        });\n    } catch (e) {\n      log.error(`Error handling request: ${inspect(e)}`, { error: e });\n      next(e);\n    }\n  };\n}\n\nfunction maskSensitiveUrl(req) {\n  let maskUrl = req.originalUrl.toString();\n  const shouldMaskUrl =\n    req.method === 'GET' &&\n    req.originalUrl.includes('/login') &&\n    !req.originalUrl.includes('classes');\n  if (shouldMaskUrl) {\n    maskUrl = log.maskSensitiveUrl(maskUrl);\n  }\n  return maskUrl;\n}\n"],"mappings":";;;;;;AAOA,IAAAA,KAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,QAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,OAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,KAAA,GAAAH,OAAA;AAA+B,SAAAD,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAV/B;AACA;AACA;AACA;AACA;AACA;;AAMA,MAAMG,KAAK,GAAGP,OAAO,CAAC,kBAAkB,CAAC;AAEzC,SAASQ,iBAAiBA,CAACC,GAAG,EAAEC,KAAK,EAAE;EACrC,IAAID,GAAG,IAAI,WAAW,EAAE;IACtB,IAAIC,KAAK,CAACC,KAAK,CAAC,yBAAyB,CAAC,EAAE;MAC1C,OAAOD,KAAK;IACd;EACF,CAAC,MAAM,IAAID,GAAG,IAAI,UAAU,EAAE;IAC5B,IAAIC,KAAK,CAACC,KAAK,CAAC,cAAc,CAAC,EAAE;MAC/B,OAAOD,KAAK;IACd;EACF,CAAC,MAAM;IACL,OAAOA,KAAK;EACd;AACF;AAEe,MAAME,aAAa,CAAC;EACjC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACAC,WAAWA,CAACC,MAAM,GAAG,EAAE,EAAEC,KAAK,EAAE;IAC9B,IAAI,CAACD,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,WAAW,CAAC,CAAC;EACpB;;EAEA;EACA;EACAA,WAAWA,CAAA,EAAG,CAAC;;EAEf;EACAC,KAAKA,CAACC,MAAM,EAAE;IACZ,KAAK,IAAIC,KAAK,IAAID,MAAM,CAACJ,MAAM,EAAE;MAC/B,IAAI,CAACA,MAAM,CAACM,IAAI,CAACD,KAAK,CAAC;IACzB;EACF;EAEAA,KAAKA,CAACE,MAAM,EAAEC,IAAI,EAAE,GAAGC,QAAQ,EAAE;IAC/B,QAAQF,MAAM;MACZ,KAAK,MAAM;MACX,KAAK,KAAK;MACV,KAAK,KAAK;MACV,KAAK,QAAQ;QACX;MACF;QACE,MAAM,uBAAuB,GAAGA,MAAM;IAC1C;IAEA,IAAIG,OAAO,GAAGD,QAAQ,CAAC,CAAC,CAAC;IAEzB,IAAIA,QAAQ,CAACE,MAAM,GAAG,CAAC,EAAE;MACvBD,OAAO,GAAG,SAAAA,CAAUE,GAAG,EAAE;QACvB,OAAOH,QAAQ,CAACI,MAAM,CAAC,CAACC,OAAO,EAAEJ,OAAO,KAAK;UAC3C,OAAOI,OAAO,CAACC,IAAI,CAAC,MAAM;YACxB,OAAOL,OAAO,CAACE,GAAG,CAAC;UACrB,CAAC,CAAC;QACJ,CAAC,EAAEI,OAAO,CAACC,OAAO,CAAC,CAAC,CAAC;MACvB,CAAC;IACH;IAEA,IAAI,CAACjB,MAAM,CAACM,IAAI,CAAC;MACfE,IAAI,EAAEA,IAAI;MACVD,MAAM,EAAEA,MAAM;MACdG,OAAO,EAAEA,OAAO;MAChBQ,KAAK,EAAE,IAAIzB,KAAK,CAACe,IAAI,EAAE,IAAI,EAAEE,OAAO;IACtC,CAAC,CAAC;EACJ;;EAEA;EACA;EACA;EACA;EACAb,KAAKA,CAACU,MAAM,EAAEC,IAAI,EAAE;IAClB,KAAK,IAAIH,KAAK,IAAI,IAAI,CAACL,MAAM,EAAE;MAC7B,IAAIK,KAAK,CAACE,MAAM,IAAIA,MAAM,EAAE;QAC1B;MACF;MACA,MAAMW,KAAK,GAAGb,KAAK,CAACa,KAAK,IAAI,IAAIzB,KAAK,CAACY,KAAK,CAACG,IAAI,EAAE,IAAI,EAAEH,KAAK,CAACK,OAAO,CAAC;MACvE,MAAMb,KAAK,GAAGqB,KAAK,CAACrB,KAAK,CAACW,IAAI,CAAC;MAC/B,IAAIX,KAAK,EAAE;QACT,MAAMsB,MAAM,GAAGD,KAAK,CAACC,MAAM;QAC3BC,MAAM,CAACC,IAAI,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC3B,GAAG,IAAI;UACjCwB,MAAM,CAACxB,GAAG,CAAC,GAAGD,iBAAiB,CAACC,GAAG,EAAEwB,MAAM,CAACxB,GAAG,CAAC,CAAC;QACnD,CAAC,CAAC;QACF,OAAO;UAAEwB,MAAM,EAAEA,MAAM;UAAET,OAAO,EAAEL,KAAK,CAACK;QAAQ,CAAC;MACnD;IACF;EACF;;EAEA;EACAa,SAASA,CAACC,UAAU,EAAE;IACpB,IAAI,CAACxB,MAAM,CAACsB,OAAO,CAACjB,KAAK,IAAI;MAC3B,MAAME,MAAM,GAAGF,KAAK,CAACE,MAAM,CAACkB,WAAW,CAAC,CAAC;MACzC,MAAMf,OAAO,GAAGgB,kBAAkB,CAAC,IAAI,CAACzB,KAAK,EAAEI,KAAK,CAACK,OAAO,CAAC;MAC7Dc,UAAU,CAACjB,MAAM,CAAC,CAACoB,IAAI,CAACH,UAAU,EAAEnB,KAAK,CAACG,IAAI,EAAEE,OAAO,CAAC;IAC1D,CAAC,CAAC;IACF,OAAOc,UAAU;EACnB;EAEAI,aAAaA,CAAA,EAAG;IACd,OAAO,IAAI,CAACL,SAAS,CAACM,gBAAO,CAACC,MAAM,CAAC,CAAC,CAAC;EACzC;EAEAC,eAAeA,CAACxB,MAAM,EAAEC,IAAI,EAAEwB,OAAO,EAAE;IACrC,IAAInC,KAAK,GAAG,IAAI,CAACA,KAAK,CAACU,MAAM,EAAEC,IAAI,CAAC;IACpC,IAAI,CAACX,KAAK,EAAE;MACV,MAAM,IAAIoC,aAAK,CAACC,KAAK,CAACD,aAAK,CAACC,KAAK,CAACC,YAAY,EAAE,eAAe,GAAG5B,MAAM,GAAG,GAAG,GAAGC,IAAI,CAAC;IACxF;IACAwB,OAAO,CAACb,MAAM,GAAGtB,KAAK,CAACsB,MAAM;IAC7B,OAAO,IAAIH,OAAO,CAAC,CAACC,OAAO,EAAEmB,MAAM,KAAK;MACtCvC,KAAK,CAACa,OAAO,CAACsB,OAAO,CAAC,CAACjB,IAAI,CAACE,OAAO,EAAEmB,MAAM,CAAC;IAC9C,CAAC,CAAC;EACJ;AACF;;AAEA;AACA;AACA;AACA;AAAAC,OAAA,CAAA7C,OAAA,GAAAM,aAAA;AACA,SAAS4B,kBAAkBA,CAACzB,KAAK,EAAEqC,cAAc,EAAE;EACjD,OAAO,UAAU1B,GAAG,EAAE2B,GAAG,EAAEC,IAAI,EAAE;IAC/B,IAAI;MACF,MAAMC,GAAG,GAAGC,gBAAgB,CAAC9B,GAAG,CAAC;MACjC,MAAM+B,IAAI,GAAGvB,MAAM,CAACwB,MAAM,CAAC,CAAC,CAAC,EAAEhC,GAAG,CAAC+B,IAAI,CAAC;MACxC,MAAMpC,MAAM,GAAGK,GAAG,CAACL,MAAM;MACzB,MAAMsC,OAAO,GAAGjC,GAAG,CAACiC,OAAO;MAC3BC,eAAG,CAACC,UAAU,CAAC;QACbxC,MAAM;QACNkC,GAAG;QACHI,OAAO;QACPF;MACF,CAAC,CAAC;MACFL,cAAc,CAAC1B,GAAG,CAAC,CAChBG,IAAI,CACHiC,MAAM,IAAI;QACR,IAAI,CAACA,MAAM,CAACC,QAAQ,IAAI,CAACD,MAAM,CAACE,QAAQ,IAAI,CAACF,MAAM,CAACG,IAAI,EAAE;UACxDL,eAAG,CAACM,KAAK,CAAC,gEAAgE,CAAC;UAC3E,MAAM,6BAA6B;QACrC;QAEAN,eAAG,CAACO,WAAW,CAAC;UAAE9C,MAAM;UAAEkC,GAAG;UAAEO;QAAO,CAAC,CAAC;QAExC,IAAIM,MAAM,GAAGN,MAAM,CAACM,MAAM,IAAI,GAAG;QACjCf,GAAG,CAACe,MAAM,CAACA,MAAM,CAAC;QAElB,IAAIN,MAAM,CAACH,OAAO,EAAE;UAClBzB,MAAM,CAACC,IAAI,CAAC2B,MAAM,CAACH,OAAO,CAAC,CAACvB,OAAO,CAACiC,MAAM,IAAI;YAC5ChB,GAAG,CAACiB,GAAG,CAACD,MAAM,EAAEP,MAAM,CAACH,OAAO,CAACU,MAAM,CAAC,CAAC;UACzC,CAAC,CAAC;QACJ;QAEA,IAAIP,MAAM,CAACG,IAAI,EAAE;UACfZ,GAAG,CAACkB,IAAI,CAACT,MAAM,CAACG,IAAI,CAAC;UACrB;QACF;QAEA,IAAIH,MAAM,CAACE,QAAQ,EAAE;UACnBX,GAAG,CAACiB,GAAG,CAAC,UAAU,EAAER,MAAM,CAACE,QAAQ,CAAC;UACpC;UACA;UACA,IAAI,CAACF,MAAM,CAACC,QAAQ,EAAE;YACpBV,GAAG,CAACkB,IAAI,CAAC,wBAAwB,GAAGT,MAAM,CAACE,QAAQ,CAAC;YACpD;UACF;QACF;QACAX,GAAG,CAACmB,IAAI,CAACV,MAAM,CAACC,QAAQ,CAAC;MAC3B,CAAC,EACDG,KAAK,IAAI;QACPZ,IAAI,CAACY,KAAK,CAAC;MACb,CACF,CAAC,CACAO,KAAK,CAACrE,CAAC,IAAI;QACVwD,eAAG,CAACM,KAAK,CAAC,8BAA8B,IAAAQ,aAAO,EAACtE,CAAC,CAAC,EAAE,EAAE;UAAE8D,KAAK,EAAE9D;QAAE,CAAC,CAAC;QACnEkD,IAAI,CAAClD,CAAC,CAAC;MACT,CAAC,CAAC;IACN,CAAC,CAAC,OAAOA,CAAC,EAAE;MACVwD,eAAG,CAACM,KAAK,CAAC,2BAA2B,IAAAQ,aAAO,EAACtE,CAAC,CAAC,EAAE,EAAE;QAAE8D,KAAK,EAAE9D;MAAE,CAAC,CAAC;MAChEkD,IAAI,CAAClD,CAAC,CAAC;IACT;EACF,CAAC;AACH;AAEA,SAASoD,gBAAgBA,CAAC9B,GAAG,EAAE;EAC7B,IAAIiD,OAAO,GAAGjD,GAAG,CAACkD,WAAW,CAACC,QAAQ,CAAC,CAAC;EACxC,MAAMC,aAAa,GACjBpD,GAAG,CAACL,MAAM,KAAK,KAAK,IACpBK,GAAG,CAACkD,WAAW,CAACG,QAAQ,CAAC,QAAQ,CAAC,IAClC,CAACrD,GAAG,CAACkD,WAAW,CAACG,QAAQ,CAAC,SAAS,CAAC;EACtC,IAAID,aAAa,EAAE;IACjBH,OAAO,GAAGf,eAAG,CAACJ,gBAAgB,CAACmB,OAAO,CAAC;EACzC;EACA,OAAOA,OAAO;AAChB","ignoreList":[]}

package/lib/Push/PushQueue.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PushQueue = void 0;
+var _ParseMessageQueue = require("../ParseMessageQueue");
+var _rest = _interopRequireDefault(require("../rest"));
+var _utils = require("./utils");
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const PUSH_CHANNEL = 'parse-server-push';
+const DEFAULT_BATCH_SIZE = 100;
+class PushQueue {
+  // config object of the publisher, right now it only contains the redisURL,
+  // but we may extend it later.
+  constructor(config = {}) {
+    this.channel = config.channel || PushQueue.defaultPushChannel();
+    this.batchSize = config.batchSize || DEFAULT_BATCH_SIZE;
+    this.parsePublisher = _ParseMessageQueue.ParseMessageQueue.createPublisher(config);
+  }
+  static defaultPushChannel() {
+    return `${_node.default.applicationId}-${PUSH_CHANNEL}`;
+  }
+  enqueue(body, where, config, auth, pushStatus) {
+    const limit = this.batchSize;
+    where = (0, _utils.applyDeviceTokenExists)(where);
+
+    // Order by objectId so no impact on the DB
+    const order = 'objectId';
+    return Promise.resolve().then(() => {
+      return _rest.default.find(config, auth, '_Installation', where, {
+        limit: 0,
+        count: true
+      });
+    }).then(({
+      results,
+      count
+    }) => {
+      if (!results || count == 0) {
+        return pushStatus.complete();
+      }
+      pushStatus.setRunning(Math.ceil(count / limit));
+      let skip = 0;
+      while (skip < count) {
+        const query = {
+          where,
+          limit,
+          skip,
+          order
+        };
+        const pushWorkItem = {
+          body,
+          query,
+          pushStatus: {
+            objectId: pushStatus.objectId
+          },
+          applicationId: config.applicationId
+        };
+        this.parsePublisher.publish(this.channel, JSON.stringify(pushWorkItem));
+        skip += limit;
+      }
+    });
+  }
+}
+exports.PushQueue = PushQueue;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Push/PushWorker.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PushWorker = void 0;
+var _AdaptableController = _interopRequireDefault(require("../Controllers/AdaptableController"));
+var _Auth = require("../Auth");
+var _Config = _interopRequireDefault(require("../Config"));
+var _PushAdapter = require("../Adapters/Push/PushAdapter");
+var _rest = _interopRequireDefault(require("../rest"));
+var _StatusHandler = require("../StatusHandler");
+var utils = _interopRequireWildcard(require("./utils"));
+var _ParseMessageQueue = require("../ParseMessageQueue");
+var _PushQueue = require("./PushQueue");
+var _logger = _interopRequireDefault(require("../logger"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function groupByBadge(installations) {
+  return installations.reduce((map, installation) => {
+    const badge = installation.badge + '';
+    map[badge] = map[badge] || [];
+    map[badge].push(installation);
+    return map;
+  }, {});
+}
+class PushWorker {
+  constructor(pushAdapter, subscriberConfig = {}) {
+    _AdaptableController.default.validateAdapter(pushAdapter, this, _PushAdapter.PushAdapter);
+    this.adapter = pushAdapter;
+    this.channel = subscriberConfig.channel || _PushQueue.PushQueue.defaultPushChannel();
+    this.subscriber = _ParseMessageQueue.ParseMessageQueue.createSubscriber(subscriberConfig);
+    if (this.subscriber) {
+      const subscriber = this.subscriber;
+      subscriber.subscribe(this.channel);
+      subscriber.on('message', (channel, messageStr) => {
+        const workItem = JSON.parse(messageStr);
+        this.run(workItem);
+      });
+    }
+  }
+  run({
+    body,
+    query,
+    pushStatus,
+    applicationId,
+    UTCOffset
+  }) {
+    const config = _Config.default.get(applicationId);
+    const auth = (0, _Auth.master)(config);
+    const where = utils.applyDeviceTokenExists(query.where);
+    delete query.where;
+    pushStatus = (0, _StatusHandler.pushStatusHandler)(config, pushStatus.objectId);
+    return _rest.default.find(config, auth, '_Installation', where, query).then(({
+      results
+    }) => {
+      if (results.length == 0) {
+        return;
+      }
+      return this.sendToAdapter(body, results, pushStatus, config, UTCOffset);
+    });
+  }
+  sendToAdapter(body, installations, pushStatus, config, UTCOffset) {
+    // Check if we have locales in the push body
+    const locales = utils.getLocalesFromPush(body);
+    if (locales.length > 0) {
+      // Get all tranformed bodies for each locale
+      const bodiesPerLocales = utils.bodiesPerLocales(body, locales);
+
+      // Group installations on the specified locales (en, fr, default etc...)
+      const grouppedInstallations = utils.groupByLocaleIdentifier(installations, locales);
+      const promises = Object.keys(grouppedInstallations).map(locale => {
+        const installations = grouppedInstallations[locale];
+        const body = bodiesPerLocales[locale];
+        return this.sendToAdapter(body, installations, pushStatus, config, UTCOffset);
+      });
+      return Promise.all(promises);
+    }
+    if (!utils.isPushIncrementing(body)) {
+      _logger.default.verbose(`Sending push to ${installations.length}`);
+      return this.adapter.send(body, installations, pushStatus.objectId).then(results => {
+        return pushStatus.trackSent(results, UTCOffset).then(() => results);
+      });
+    }
+
+    // Collect the badges to reduce the # of calls
+    const badgeInstallationsMap = groupByBadge(installations);
+
+    // Map the on the badges count and return the send result
+    const promises = Object.keys(badgeInstallationsMap).map(badge => {
+      const payload = structuredClone(body);
+      payload.data.badge = parseInt(badge);
+      const installations = badgeInstallationsMap[badge];
+      return this.sendToAdapter(payload, installations, pushStatus, config, UTCOffset);
+    });
+    return Promise.all(promises);
+  }
+}
+exports.PushWorker = PushWorker;
+var _default = exports.default = PushWorker;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_AdaptableController","_interopRequireDefault","require","_Auth","_Config","_PushAdapter","_rest","_StatusHandler","utils","_interopRequireWildcard","_ParseMessageQueue","_PushQueue","_logger","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","groupByBadge","installations","reduce","map","installation","badge","push","PushWorker","constructor","pushAdapter","subscriberConfig","AdaptableController","validateAdapter","PushAdapter","adapter","channel","PushQueue","defaultPushChannel","subscriber","ParseMessageQueue","createSubscriber","subscribe","on","messageStr","workItem","JSON","parse","run","body","query","pushStatus","applicationId","UTCOffset","config","Config","auth","master","where","applyDeviceTokenExists","pushStatusHandler","objectId","rest","find","then","results","length","sendToAdapter","locales","getLocalesFromPush","bodiesPerLocales","grouppedInstallations","groupByLocaleIdentifier","promises","keys","locale","Promise","all","isPushIncrementing","logger","verbose","send","trackSent","badgeInstallationsMap","payload","structuredClone","data","parseInt","exports","_default"],"sources":["../../src/Push/PushWorker.js"],"sourcesContent":["// @flow\nimport AdaptableController from '../Controllers/AdaptableController';\nimport { master } from '../Auth';\nimport Config from '../Config';\nimport { PushAdapter } from '../Adapters/Push/PushAdapter';\nimport rest from '../rest';\nimport { pushStatusHandler } from '../StatusHandler';\nimport * as utils from './utils';\nimport { ParseMessageQueue } from '../ParseMessageQueue';\nimport { PushQueue } from './PushQueue';\nimport logger from '../logger';\n\nfunction groupByBadge(installations) {\n  return installations.reduce((map, installation) => {\n    const badge = installation.badge + '';\n    map[badge] = map[badge] || [];\n    map[badge].push(installation);\n    return map;\n  }, {});\n}\n\nexport class PushWorker {\n  subscriber: ?any;\n  adapter: any;\n  channel: string;\n\n  constructor(pushAdapter: PushAdapter, subscriberConfig: any = {}) {\n    AdaptableController.validateAdapter(pushAdapter, this, PushAdapter);\n    this.adapter = pushAdapter;\n\n    this.channel = subscriberConfig.channel || PushQueue.defaultPushChannel();\n    this.subscriber = ParseMessageQueue.createSubscriber(subscriberConfig);\n    if (this.subscriber) {\n      const subscriber = this.subscriber;\n      subscriber.subscribe(this.channel);\n      subscriber.on('message', (channel, messageStr) => {\n        const workItem = JSON.parse(messageStr);\n        this.run(workItem);\n      });\n    }\n  }\n\n  run({ body, query, pushStatus, applicationId, UTCOffset }: any): Promise<*> {\n    const config = Config.get(applicationId);\n    const auth = master(config);\n    const where = utils.applyDeviceTokenExists(query.where);\n    delete query.where;\n    pushStatus = pushStatusHandler(config, pushStatus.objectId);\n    return rest.find(config, auth, '_Installation', where, query).then(({ results }) => {\n      if (results.length == 0) {\n        return;\n      }\n      return this.sendToAdapter(body, results, pushStatus, config, UTCOffset);\n    });\n  }\n\n  sendToAdapter(\n    body: any,\n    installations: any[],\n    pushStatus: any,\n    config: Config,\n    UTCOffset: ?any\n  ): Promise<*> {\n    // Check if we have locales in the push body\n    const locales = utils.getLocalesFromPush(body);\n    if (locales.length > 0) {\n      // Get all tranformed bodies for each locale\n      const bodiesPerLocales = utils.bodiesPerLocales(body, locales);\n\n      // Group installations on the specified locales (en, fr, default etc...)\n      const grouppedInstallations = utils.groupByLocaleIdentifier(installations, locales);\n      const promises = Object.keys(grouppedInstallations).map(locale => {\n        const installations = grouppedInstallations[locale];\n        const body = bodiesPerLocales[locale];\n        return this.sendToAdapter(body, installations, pushStatus, config, UTCOffset);\n      });\n      return Promise.all(promises);\n    }\n\n    if (!utils.isPushIncrementing(body)) {\n      logger.verbose(`Sending push to ${installations.length}`);\n      return this.adapter.send(body, installations, pushStatus.objectId).then(results => {\n        return pushStatus.trackSent(results, UTCOffset).then(() => results);\n      });\n    }\n\n    // Collect the badges to reduce the # of calls\n    const badgeInstallationsMap = groupByBadge(installations);\n\n    // Map the on the badges count and return the send result\n    const promises = Object.keys(badgeInstallationsMap).map(badge => {\n      const payload = structuredClone(body);\n      payload.data.badge = parseInt(badge);\n      const installations = badgeInstallationsMap[badge];\n      return this.sendToAdapter(payload, installations, pushStatus, config, UTCOffset);\n    });\n    return Promise.all(promises);\n  }\n}\n\nexport default PushWorker;\n"],"mappings":"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","ignoreList":[]}