@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/batch.js

@@ -0,0 +1,185 @@
+"use strict";
+
+const Parse = require('parse/node').Parse;
+const path = require('path');
+// These methods handle batch requests.
+const batchPath = '/batch';
+
+// Mounts a batch-handler onto a PromiseRouter.
+function mountOnto(router) {
+  router.route('POST', batchPath, req => {
+    return handleBatch(router, req);
+  });
+}
+function parseURL(urlString) {
+  try {
+    return new URL(urlString);
+  } catch {
+    return undefined;
+  }
+}
+function makeBatchRoutingPathFunction(originalUrl, serverURL, publicServerURL) {
+  serverURL = serverURL ? parseURL(serverURL) : undefined;
+  publicServerURL = publicServerURL ? parseURL(publicServerURL) : undefined;
+  const apiPrefixLength = originalUrl.length - batchPath.length;
+  let apiPrefix = originalUrl.slice(0, apiPrefixLength);
+  const makeRoutablePath = function (requestPath) {
+    // The routablePath is the path minus the api prefix
+    if (requestPath.slice(0, apiPrefix.length) != apiPrefix) {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot route batch path ' + requestPath);
+    }
+    return path.posix.join('/', requestPath.slice(apiPrefix.length));
+  };
+  if (serverURL && publicServerURL && serverURL.pathname != publicServerURL.pathname) {
+    const localPath = serverURL.pathname;
+    const publicPath = publicServerURL.pathname;
+
+    // Override the api prefix
+    apiPrefix = localPath;
+    return function (requestPath) {
+      // Figure out which server url was used by figuring out which
+      // path more closely matches requestPath
+      const startsWithLocal = requestPath.startsWith(localPath);
+      const startsWithPublic = requestPath.startsWith(publicPath);
+      const pathLengthToUse = startsWithLocal && startsWithPublic ? Math.max(localPath.length, publicPath.length) : startsWithLocal ? localPath.length : publicPath.length;
+      const newPath = path.posix.join('/', localPath, '/', requestPath.slice(pathLengthToUse));
+
+      // Use the method for local routing
+      return makeRoutablePath(newPath);
+    };
+  }
+  return makeRoutablePath;
+}
+
+// Returns a promise for a {response} object.
+// TODO: pass along auth correctly
+async function handleBatch(router, req) {
+  if (!Array.isArray(req.body?.requests)) {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, 'requests must be an array');
+  }
+  const batchRequestLimit = req.config?.requestComplexity?.batchRequestLimit ?? -1;
+  if (batchRequestLimit > -1 && !req.auth?.isMaster && !req.auth?.isMaintenance && req.body.requests.length > batchRequestLimit) {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, `Batch request contains ${req.body.requests.length} sub-requests, which exceeds the limit of ${batchRequestLimit}.`);
+  }
+  for (const restRequest of req.body.requests) {
+    if (!restRequest || typeof restRequest !== 'object' || typeof restRequest.path !== 'string') {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, 'batch request path must be a string');
+    }
+  }
+
+  // The batch paths are all from the root of our domain.
+  // That means they include the API prefix, that the API is mounted
+  // to. However, our promise router does not route the api prefix. So
+  // we need to figure out the API prefix, so that we can strip it
+  // from all the subrequests.
+  if (!req.originalUrl.endsWith(batchPath)) {
+    throw 'internal routing problem - expected url to end with batch';
+  }
+  const makeRoutablePath = makeBatchRoutingPathFunction(req.originalUrl, req.config.serverURL, req.config.publicServerURL);
+
+  // Enforce rate limits for each batch sub-request by invoking the
+  // rate limit handler. This ensures sub-requests consume tokens from
+  // the same window state as direct requests.
+  const rateLimits = req.config.rateLimits || [];
+  for (const restRequest of req.body.requests) {
+    const routablePath = makeRoutablePath(restRequest.path);
+    if ((restRequest.method || 'GET').toUpperCase() === 'POST' && routablePath === batchPath) {
+      throw new Parse.Error(Parse.Error.INVALID_JSON, 'nested batch requests are not allowed');
+    }
+    for (const limit of rateLimits) {
+      const pathExp = limit.path.regexp || limit.path;
+      if (!pathExp.test(routablePath)) {
+        continue;
+      }
+      const info = {
+        ...req.info
+      };
+      if (routablePath === '/login') {
+        delete info.sessionToken;
+      }
+      const fakeReq = {
+        ip: req.ip || req.config?.ip || '127.0.0.1',
+        method: (restRequest.method || 'GET').toUpperCase(),
+        _batchOriginalMethod: 'POST',
+        config: req.config,
+        auth: req.auth,
+        info
+      };
+      const fakeRes = {
+        setHeader() {}
+      };
+      try {
+        await limit.handler(fakeReq, fakeRes, err => {
+          if (err) {
+            throw err;
+          }
+        });
+      } catch {
+        throw new Parse.Error(Parse.Error.CONNECTION_FAILED, limit.errorResponseMessage || 'Too many requests');
+      }
+    }
+  }
+  const batch = transactionRetries => {
+    let initialPromise = Promise.resolve();
+    if (req.body?.transaction === true) {
+      initialPromise = req.config.database.createTransactionalSession();
+    }
+    return initialPromise.then(() => {
+      const promises = req.body?.requests.map(restRequest => {
+        const routablePath = makeRoutablePath(restRequest.path);
+
+        // Construct a request that we can send to a handler
+        const request = {
+          body: restRequest.body,
+          config: req.config,
+          auth: req.auth,
+          info: req.info
+        };
+        return router.tryRouteRequest(restRequest.method, routablePath, request).then(response => {
+          return {
+            success: response.response
+          };
+        }, error => {
+          return {
+            error: {
+              code: error.code,
+              error: error.message
+            }
+          };
+        });
+      });
+      return Promise.all(promises).then(results => {
+        if (req.body?.transaction === true) {
+          if (results.find(result => typeof result.error === 'object')) {
+            return req.config.database.abortTransactionalSession().then(() => {
+              return Promise.reject({
+                response: results
+              });
+            });
+          } else {
+            return req.config.database.commitTransactionalSession().then(() => {
+              return {
+                response: results
+              };
+            });
+          }
+        } else {
+          return {
+            response: results
+          };
+        }
+      }).catch(error => {
+        if (error && error.response && error.response.find(errorItem => typeof errorItem.error === 'object' && errorItem.error.code === 251) && transactionRetries > 0) {
+          return batch(transactionRetries - 1);
+        }
+        throw error;
+      });
+    });
+  };
+  return batch(5);
+}
+module.exports = {
+  mountOnto,
+  makeBatchRoutingPathFunction
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","path","batchPath","mountOnto","router","route","req","handleBatch","parseURL","urlString","URL","undefined","makeBatchRoutingPathFunction","originalUrl","serverURL","publicServerURL","apiPrefixLength","length","apiPrefix","slice","makeRoutablePath","requestPath","Error","INVALID_JSON","posix","join","pathname","localPath","publicPath","startsWithLocal","startsWith","startsWithPublic","pathLengthToUse","Math","max","newPath","Array","isArray","body","requests","batchRequestLimit","config","requestComplexity","auth","isMaster","isMaintenance","restRequest","endsWith","rateLimits","routablePath","method","toUpperCase","limit","pathExp","regexp","test","info","sessionToken","fakeReq","ip","_batchOriginalMethod","fakeRes","setHeader","handler","err","CONNECTION_FAILED","errorResponseMessage","batch","transactionRetries","initialPromise","Promise","resolve","transaction","database","createTransactionalSession","then","promises","map","request","tryRouteRequest","response","success","error","code","message","all","results","find","result","abortTransactionalSession","reject","commitTransactionalSession","catch","errorItem","module","exports"],"sources":["../src/batch.js"],"sourcesContent":["const Parse = require('parse/node').Parse;\nconst path = require('path');\n// These methods handle batch requests.\nconst batchPath = '/batch';\n\n// Mounts a batch-handler onto a PromiseRouter.\nfunction mountOnto(router) {\n  router.route('POST', batchPath, req => {\n    return handleBatch(router, req);\n  });\n}\n\nfunction parseURL(urlString) {\n  try {\n    return new URL(urlString);\n  } catch {\n    return undefined;\n  }\n}\n\nfunction makeBatchRoutingPathFunction(originalUrl, serverURL, publicServerURL) {\n  serverURL = serverURL ? parseURL(serverURL) : undefined;\n  publicServerURL = publicServerURL ? parseURL(publicServerURL) : undefined;\n\n  const apiPrefixLength = originalUrl.length - batchPath.length;\n  let apiPrefix = originalUrl.slice(0, apiPrefixLength);\n\n  const makeRoutablePath = function (requestPath) {\n    // The routablePath is the path minus the api prefix\n    if (requestPath.slice(0, apiPrefix.length) != apiPrefix) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot route batch path ' + requestPath);\n    }\n    return path.posix.join('/', requestPath.slice(apiPrefix.length));\n  };\n\n  if (serverURL && publicServerURL && serverURL.pathname != publicServerURL.pathname) {\n    const localPath = serverURL.pathname;\n    const publicPath = publicServerURL.pathname;\n\n    // Override the api prefix\n    apiPrefix = localPath;\n    return function (requestPath) {\n      // Figure out which server url was used by figuring out which\n      // path more closely matches requestPath\n      const startsWithLocal = requestPath.startsWith(localPath);\n      const startsWithPublic = requestPath.startsWith(publicPath);\n      const pathLengthToUse =\n        startsWithLocal && startsWithPublic\n          ? Math.max(localPath.length, publicPath.length)\n          : startsWithLocal\n            ? localPath.length\n            : publicPath.length;\n\n      const newPath = path.posix.join('/', localPath, '/', requestPath.slice(pathLengthToUse));\n\n      // Use the method for local routing\n      return makeRoutablePath(newPath);\n    };\n  }\n\n  return makeRoutablePath;\n}\n\n// Returns a promise for a {response} object.\n// TODO: pass along auth correctly\nasync function handleBatch(router, req) {\n  if (!Array.isArray(req.body?.requests)) {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, 'requests must be an array');\n  }\n  const batchRequestLimit = req.config?.requestComplexity?.batchRequestLimit ?? -1;\n  if (batchRequestLimit > -1 && !req.auth?.isMaster && !req.auth?.isMaintenance && req.body.requests.length > batchRequestLimit) {\n    throw new Parse.Error(\n      Parse.Error.INVALID_JSON,\n      `Batch request contains ${req.body.requests.length} sub-requests, which exceeds the limit of ${batchRequestLimit}.`\n    );\n  }\n  for (const restRequest of req.body.requests) {\n    if (!restRequest || typeof restRequest !== 'object' || typeof restRequest.path !== 'string') {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'batch request path must be a string');\n    }\n  }\n\n  // The batch paths are all from the root of our domain.\n  // That means they include the API prefix, that the API is mounted\n  // to. However, our promise router does not route the api prefix. So\n  // we need to figure out the API prefix, so that we can strip it\n  // from all the subrequests.\n  if (!req.originalUrl.endsWith(batchPath)) {\n    throw 'internal routing problem - expected url to end with batch';\n  }\n\n  const makeRoutablePath = makeBatchRoutingPathFunction(\n    req.originalUrl,\n    req.config.serverURL,\n    req.config.publicServerURL\n  );\n\n  // Enforce rate limits for each batch sub-request by invoking the\n  // rate limit handler. This ensures sub-requests consume tokens from\n  // the same window state as direct requests.\n  const rateLimits = req.config.rateLimits || [];\n  for (const restRequest of req.body.requests) {\n    const routablePath = makeRoutablePath(restRequest.path);\n    if ((restRequest.method || 'GET').toUpperCase() === 'POST' && routablePath === batchPath) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'nested batch requests are not allowed');\n    }\n    for (const limit of rateLimits) {\n      const pathExp = limit.path.regexp || limit.path;\n      if (!pathExp.test(routablePath)) {\n        continue;\n      }\n      const info = { ...req.info };\n      if (routablePath === '/login') {\n        delete info.sessionToken;\n      }\n      const fakeReq = {\n        ip: req.ip || req.config?.ip || '127.0.0.1',\n        method: (restRequest.method || 'GET').toUpperCase(),\n        _batchOriginalMethod: 'POST',\n        config: req.config,\n        auth: req.auth,\n        info,\n      };\n      const fakeRes = { setHeader() {} };\n      try {\n        await limit.handler(fakeReq, fakeRes, err => {\n          if (err) {\n            throw err;\n          }\n        });\n      } catch {\n        throw new Parse.Error(\n          Parse.Error.CONNECTION_FAILED,\n          limit.errorResponseMessage || 'Too many requests'\n        );\n      }\n    }\n  }\n\n  const batch = transactionRetries => {\n    let initialPromise = Promise.resolve();\n    if (req.body?.transaction === true) {\n      initialPromise = req.config.database.createTransactionalSession();\n    }\n\n    return initialPromise.then(() => {\n      const promises = req.body?.requests.map(restRequest => {\n        const routablePath = makeRoutablePath(restRequest.path);\n\n        // Construct a request that we can send to a handler\n        const request = {\n          body: restRequest.body,\n          config: req.config,\n          auth: req.auth,\n          info: req.info,\n        };\n\n        return router.tryRouteRequest(restRequest.method, routablePath, request).then(\n          response => {\n            return { success: response.response };\n          },\n          error => {\n            return { error: { code: error.code, error: error.message } };\n          }\n        );\n      });\n\n      return Promise.all(promises)\n        .then(results => {\n          if (req.body?.transaction === true) {\n            if (results.find(result => typeof result.error === 'object')) {\n              return req.config.database.abortTransactionalSession().then(() => {\n                return Promise.reject({ response: results });\n              });\n            } else {\n              return req.config.database.commitTransactionalSession().then(() => {\n                return { response: results };\n              });\n            }\n          } else {\n            return { response: results };\n          }\n        })\n        .catch(error => {\n          if (\n            error &&\n            error.response &&\n            error.response.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\nmodule.exports = {\n  mountOnto,\n  makeBatchRoutingPathFunction,\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/cache.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AppCache = void 0;
+var _InMemoryCache = require("./Adapters/Cache/InMemoryCache");
+var AppCache = exports.AppCache = new _InMemoryCache.InMemoryCache({
+  ttl: NaN
+});
+var _default = exports.default = AppCache;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfSW5NZW1vcnlDYWNoZSIsInJlcXVpcmUiLCJBcHBDYWNoZSIsImV4cG9ydHMiLCJJbk1lbW9yeUNhY2hlIiwidHRsIiwiTmFOIiwiX2RlZmF1bHQiLCJkZWZhdWx0Il0sInNvdXJjZXMiOlsiLi4vc3JjL2NhY2hlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluTWVtb3J5Q2FjaGUgfSBmcm9tICcuL0FkYXB0ZXJzL0NhY2hlL0luTWVtb3J5Q2FjaGUnO1xuXG5leHBvcnQgdmFyIEFwcENhY2hlID0gbmV3IEluTWVtb3J5Q2FjaGUoeyB0dGw6IE5hTiB9KTtcbmV4cG9ydCBkZWZhdWx0IEFwcENhY2hlO1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxJQUFBQSxjQUFBLEdBQUFDLE9BQUE7QUFFTyxJQUFJQyxRQUFRLEdBQUFDLE9BQUEsQ0FBQUQsUUFBQSxHQUFHLElBQUlFLDRCQUFhLENBQUM7RUFBRUMsR0FBRyxFQUFFQztBQUFJLENBQUMsQ0FBQztBQUFDLElBQUFDLFFBQUEsR0FBQUosT0FBQSxDQUFBSyxPQUFBLEdBQ3ZDTixRQUFRIiwiaWdub3JlTGlzdCI6W119

package/lib/cli/definitions/parse-live-query-server.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const LiveQueryServerOptions = require('../../Options/Definitions').LiveQueryServerOptions;
+var _default = exports.default = LiveQueryServerOptions;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJMaXZlUXVlcnlTZXJ2ZXJPcHRpb25zIiwicmVxdWlyZSIsIl9kZWZhdWx0IiwiZXhwb3J0cyIsImRlZmF1bHQiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2xpL2RlZmluaXRpb25zL3BhcnNlLWxpdmUtcXVlcnktc2VydmVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IExpdmVRdWVyeVNlcnZlck9wdGlvbnMgPSByZXF1aXJlKCcuLi8uLi9PcHRpb25zL0RlZmluaXRpb25zJykuTGl2ZVF1ZXJ5U2VydmVyT3B0aW9ucztcbmV4cG9ydCBkZWZhdWx0IExpdmVRdWVyeVNlcnZlck9wdGlvbnM7XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLE1BQU1BLHNCQUFzQixHQUFHQyxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FBQ0Qsc0JBQXNCO0FBQUMsSUFBQUUsUUFBQSxHQUFBQyxPQUFBLENBQUFDLE9BQUEsR0FDNUVKLHNCQUFzQiIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/cli/definitions/parse-server.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const ParseServerDefinitions = require('../../Options/Definitions').ParseServerOptions;
+var _default = exports.default = ParseServerDefinitions;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJQYXJzZVNlcnZlckRlZmluaXRpb25zIiwicmVxdWlyZSIsIlBhcnNlU2VydmVyT3B0aW9ucyIsIl9kZWZhdWx0IiwiZXhwb3J0cyIsImRlZmF1bHQiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2xpL2RlZmluaXRpb25zL3BhcnNlLXNlcnZlci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBQYXJzZVNlcnZlckRlZmluaXRpb25zID0gcmVxdWlyZSgnLi4vLi4vT3B0aW9ucy9EZWZpbml0aW9ucycpLlBhcnNlU2VydmVyT3B0aW9ucztcbmV4cG9ydCBkZWZhdWx0IFBhcnNlU2VydmVyRGVmaW5pdGlvbnM7XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLE1BQU1BLHNCQUFzQixHQUFHQyxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FBQ0Msa0JBQWtCO0FBQUMsSUFBQUMsUUFBQSxHQUFBQyxPQUFBLENBQUFDLE9BQUEsR0FDeEVMLHNCQUFzQiIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/cli/parse-live-query-server.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _parseLiveQueryServer = _interopRequireDefault(require("./definitions/parse-live-query-server"));
+var _runner = _interopRequireDefault(require("./utils/runner"));
+var _index = require("../index");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _runner.default)({
+  definitions: _parseLiveQueryServer.default,
+  start: function (program, options, logOptions) {
+    logOptions();
+    _index.ParseServer.createLiveQueryServer(undefined, options);
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcGFyc2VMaXZlUXVlcnlTZXJ2ZXIiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9ydW5uZXIiLCJfaW5kZXgiLCJlIiwiX19lc01vZHVsZSIsImRlZmF1bHQiLCJydW5uZXIiLCJkZWZpbml0aW9ucyIsInN0YXJ0IiwicHJvZ3JhbSIsIm9wdGlvbnMiLCJsb2dPcHRpb25zIiwiUGFyc2VTZXJ2ZXIiLCJjcmVhdGVMaXZlUXVlcnlTZXJ2ZXIiLCJ1bmRlZmluZWQiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL3BhcnNlLWxpdmUtcXVlcnktc2VydmVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBkZWZpbml0aW9ucyBmcm9tICcuL2RlZmluaXRpb25zL3BhcnNlLWxpdmUtcXVlcnktc2VydmVyJztcbmltcG9ydCBydW5uZXIgZnJvbSAnLi91dGlscy9ydW5uZXInO1xuaW1wb3J0IHsgUGFyc2VTZXJ2ZXIgfSBmcm9tICcuLi9pbmRleCc7XG5cbnJ1bm5lcih7XG4gIGRlZmluaXRpb25zLFxuICBzdGFydDogZnVuY3Rpb24gKHByb2dyYW0sIG9wdGlvbnMsIGxvZ09wdGlvbnMpIHtcbiAgICBsb2dPcHRpb25zKCk7XG4gICAgUGFyc2VTZXJ2ZXIuY3JlYXRlTGl2ZVF1ZXJ5U2VydmVyKHVuZGVmaW5lZCwgb3B0aW9ucyk7XG4gIH0sXG59KTtcbiJdLCJtYXBwaW5ncyI6Ijs7QUFBQSxJQUFBQSxxQkFBQSxHQUFBQyxzQkFBQSxDQUFBQyxPQUFBO0FBQ0EsSUFBQUMsT0FBQSxHQUFBRixzQkFBQSxDQUFBQyxPQUFBO0FBQ0EsSUFBQUUsTUFBQSxHQUFBRixPQUFBO0FBQXVDLFNBQUFELHVCQUFBSSxDQUFBLFdBQUFBLENBQUEsSUFBQUEsQ0FBQSxDQUFBQyxVQUFBLEdBQUFELENBQUEsS0FBQUUsT0FBQSxFQUFBRixDQUFBO0FBRXZDLElBQUFHLGVBQU0sRUFBQztFQUNMQyxXQUFXLEVBQVhBLDZCQUFXO0VBQ1hDLEtBQUssRUFBRSxTQUFBQSxDQUFVQyxPQUFPLEVBQUVDLE9BQU8sRUFBRUMsVUFBVSxFQUFFO0lBQzdDQSxVQUFVLENBQUMsQ0FBQztJQUNaQyxrQkFBVyxDQUFDQyxxQkFBcUIsQ0FBQ0MsU0FBUyxFQUFFSixPQUFPLENBQUM7RUFDdkQ7QUFDRixDQUFDLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/cli/parse-server.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _index = _interopRequireDefault(require("../index"));
+var _parseServer = _interopRequireDefault(require("./definitions/parse-server"));
+var _cluster = _interopRequireDefault(require("cluster"));
+var _os = _interopRequireDefault(require("os"));
+var _runner = _interopRequireDefault(require("./utils/runner"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable no-console */
+
+const help = function () {
+  console.log('  Get Started guide:');
+  console.log('');
+  console.log('    Please have a look at the get started guide!');
+  console.log('    http://docs.parseplatform.org/parse-server/guide/');
+  console.log('');
+  console.log('');
+  console.log('  Usage with npm start');
+  console.log('');
+  console.log('    $ npm start -- path/to/config.json');
+  console.log('    $ npm start -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');
+  console.log('    $ npm start -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');
+  console.log('');
+  console.log('');
+  console.log('  Usage:');
+  console.log('');
+  console.log('    $ parse-server path/to/config.json');
+  console.log('    $ parse-server -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');
+  console.log('    $ parse-server -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');
+  console.log('');
+};
+(0, _runner.default)({
+  definitions: _parseServer.default,
+  help,
+  usage: '[options] <path/to/configuration.json>',
+  start: function (program, options, logOptions) {
+    if (!options.appId || !options.masterKey) {
+      program.outputHelp();
+      console.error('');
+      console.error('\u001b[31mERROR: appId and masterKey are required\u001b[0m');
+      console.error('');
+      process.exit(1);
+    }
+    if (options['liveQuery.classNames']) {
+      options.liveQuery = options.liveQuery || {};
+      options.liveQuery.classNames = options['liveQuery.classNames'];
+      delete options['liveQuery.classNames'];
+    }
+    if (options['liveQuery.redisURL']) {
+      options.liveQuery = options.liveQuery || {};
+      options.liveQuery.redisURL = options['liveQuery.redisURL'];
+      delete options['liveQuery.redisURL'];
+    }
+    if (options['liveQuery.redisOptions']) {
+      options.liveQuery = options.liveQuery || {};
+      options.liveQuery.redisOptions = options['liveQuery.redisOptions'];
+      delete options['liveQuery.redisOptions'];
+    }
+    if (options.cluster) {
+      const numCPUs = typeof options.cluster === 'number' ? options.cluster : _os.default.cpus().length;
+      if (_cluster.default.isMaster) {
+        logOptions();
+        for (let i = 0; i < numCPUs; i++) {
+          _cluster.default.fork();
+        }
+        _cluster.default.on('exit', (worker, code) => {
+          console.log(`worker ${worker.process.pid} died (${code})... Restarting`);
+          _cluster.default.fork();
+        });
+      } else {
+        _index.default.startApp(options).then(() => {
+          printSuccessMessage();
+        }).catch(e => {
+          console.error(e);
+          process.exit(1);
+        });
+      }
+    } else {
+      _index.default.startApp(options).then(() => {
+        logOptions();
+        console.log('');
+        printSuccessMessage();
+      }).catch(e => {
+        console.error(e);
+        process.exit(1);
+      });
+    }
+    function printSuccessMessage() {
+      console.log('[' + process.pid + '] parse-server running on ' + options.serverURL);
+      if (options.mountGraphQL) {
+        console.log('[' + process.pid + '] GraphQL running on http://localhost:' + options.port + options.graphQLPath);
+      }
+      if (options.mountPlayground) {
+        console.log('[' + process.pid + '] Playground running on http://localhost:' + options.port + options.playgroundPath);
+      }
+    }
+  }
+});
+
+/* eslint-enable no-console */
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_index","_interopRequireDefault","require","_parseServer","_cluster","_os","_runner","e","__esModule","default","help","console","log","runner","definitions","usage","start","program","options","logOptions","appId","masterKey","outputHelp","error","process","exit","liveQuery","classNames","redisURL","redisOptions","cluster","numCPUs","os","cpus","length","isMaster","i","fork","on","worker","code","pid","ParseServer","startApp","then","printSuccessMessage","catch","serverURL","mountGraphQL","port","graphQLPath","mountPlayground","playgroundPath"],"sources":["../../src/cli/parse-server.js"],"sourcesContent":["/* eslint-disable no-console */\nimport ParseServer from '../index';\nimport definitions from './definitions/parse-server';\nimport cluster from 'cluster';\nimport os from 'os';\nimport runner from './utils/runner';\n\nconst help = function () {\n  console.log('  Get Started guide:');\n  console.log('');\n  console.log('    Please have a look at the get started guide!');\n  console.log('    http://docs.parseplatform.org/parse-server/guide/');\n  console.log('');\n  console.log('');\n  console.log('  Usage with npm start');\n  console.log('');\n  console.log('    $ npm start -- path/to/config.json');\n  console.log('    $ npm start -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');\n  console.log('    $ npm start -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');\n  console.log('');\n  console.log('');\n  console.log('  Usage:');\n  console.log('');\n  console.log('    $ parse-server path/to/config.json');\n  console.log('    $ parse-server -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');\n  console.log('    $ parse-server -- --appId APP_ID --masterKey MASTER_KEY --serverURL serverURL');\n  console.log('');\n};\n\nrunner({\n  definitions,\n  help,\n  usage: '[options] <path/to/configuration.json>',\n  start: function (program, options, logOptions) {\n\n    if (!options.appId || !options.masterKey) {\n      program.outputHelp();\n      console.error('');\n      console.error('\\u001b[31mERROR: appId and masterKey are required\\u001b[0m');\n      console.error('');\n      process.exit(1);\n    }\n\n    if (options['liveQuery.classNames']) {\n      options.liveQuery = options.liveQuery || {};\n      options.liveQuery.classNames = options['liveQuery.classNames'];\n      delete options['liveQuery.classNames'];\n    }\n    if (options['liveQuery.redisURL']) {\n      options.liveQuery = options.liveQuery || {};\n      options.liveQuery.redisURL = options['liveQuery.redisURL'];\n      delete options['liveQuery.redisURL'];\n    }\n    if (options['liveQuery.redisOptions']) {\n      options.liveQuery = options.liveQuery || {};\n      options.liveQuery.redisOptions = options['liveQuery.redisOptions'];\n      delete options['liveQuery.redisOptions'];\n    }\n\n    if (options.cluster) {\n      const numCPUs = typeof options.cluster === 'number' ? options.cluster : os.cpus().length;\n      if (cluster.isMaster) {\n        logOptions();\n        for (let i = 0; i < numCPUs; i++) {\n          cluster.fork();\n        }\n        cluster.on('exit', (worker, code) => {\n          console.log(`worker ${worker.process.pid} died (${code})... Restarting`);\n          cluster.fork();\n        });\n      } else {\n        ParseServer.startApp(options)\n          .then(() => {\n            printSuccessMessage();\n          })\n          .catch(e => {\n            console.error(e);\n            process.exit(1);\n          });\n      }\n    } else {\n      ParseServer.startApp(options)\n        .then(() => {\n          logOptions();\n          console.log('');\n          printSuccessMessage();\n        })\n        .catch(e => {\n          console.error(e);\n          process.exit(1);\n        });\n    }\n\n    function printSuccessMessage() {\n      console.log('[' + process.pid + '] parse-server running on ' + options.serverURL);\n      if (options.mountGraphQL) {\n        console.log(\n          '[' +\n            process.pid +\n            '] GraphQL running on http://localhost:' +\n            options.port +\n            options.graphQLPath\n        );\n      }\n      if (options.mountPlayground) {\n        console.log(\n          '[' +\n            process.pid +\n            '] Playground running on http://localhost:' +\n            options.port +\n            options.playgroundPath\n        );\n      }\n    }\n  },\n});\n\n/* eslint-enable no-console */\n"],"mappings":"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","ignoreList":[]}

package/lib/cli/utils/commander.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _commander = require("commander");
+var _path = _interopRequireDefault(require("path"));
+var _Deprecator = _interopRequireDefault(require("../../Deprecator/Deprecator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable no-console */
+
+let _definitions;
+let _reverseDefinitions;
+let _defaults;
+_commander.Command.prototype.loadDefinitions = function (definitions) {
+  _definitions = definitions;
+  Object.keys(definitions).reduce((program, opt) => {
+    if (typeof definitions[opt] == 'object') {
+      const additionalOptions = definitions[opt];
+      if (additionalOptions.required === true) {
+        return program.option(`--${opt} <${opt}>`, additionalOptions.help, additionalOptions.action);
+      } else {
+        return program.option(`--${opt} [${opt}]`, additionalOptions.help, additionalOptions.action);
+      }
+    }
+    return program.option(`--${opt} [${opt}]`);
+  }, this);
+  _reverseDefinitions = Object.keys(definitions).reduce((object, key) => {
+    let value = definitions[key];
+    if (typeof value == 'object') {
+      value = value.env;
+    }
+    if (value) {
+      object[value] = key;
+    }
+    return object;
+  }, {});
+  _defaults = Object.keys(definitions).reduce((defs, opt) => {
+    if (_definitions[opt].default !== undefined) {
+      defs[opt] = _definitions[opt].default;
+    }
+    return defs;
+  }, {});
+
+  /* istanbul ignore next */
+  this.on('--help', function () {
+    console.log('  Configure From Environment:');
+    console.log('');
+    Object.keys(_reverseDefinitions).forEach(key => {
+      console.log(`    $ ${key}='${_reverseDefinitions[key]}'`);
+    });
+    console.log('');
+  });
+};
+function parseEnvironment(env = {}) {
+  return Object.keys(_reverseDefinitions).reduce((options, key) => {
+    if (env[key]) {
+      const originalKey = _reverseDefinitions[key];
+      let action = option => option;
+      if (typeof _definitions[originalKey] === 'object') {
+        action = _definitions[originalKey].action || action;
+      }
+      options[_reverseDefinitions[key]] = action(env[key]);
+    }
+    return options;
+  }, {});
+}
+function parseConfigFile(program) {
+  let options = {};
+  if (program.args.length > 0) {
+    let jsonPath = program.args[0];
+    jsonPath = _path.default.resolve(jsonPath);
+    const jsonConfig = require(jsonPath);
+    if (jsonConfig.apps) {
+      if (jsonConfig.apps.length > 1) {
+        throw 'Multiple apps are not supported';
+      }
+      options = jsonConfig.apps[0];
+    } else {
+      options = jsonConfig;
+    }
+    Object.keys(options).forEach(key => {
+      const value = options[key];
+      if (!_definitions[key]) {
+        throw `error: unknown option ${key}`;
+      }
+      const action = _definitions[key].action;
+      if (action) {
+        options[key] = action(value);
+      }
+    });
+    console.log(`Configuration loaded from ${jsonPath}`);
+  }
+  return options;
+}
+_commander.Command.prototype.setValuesIfNeeded = function (options) {
+  Object.keys(options).forEach(key => {
+    if (!Object.prototype.hasOwnProperty.call(this, key)) {
+      this[key] = options[key];
+    }
+  });
+};
+_commander.Command.prototype._parse = _commander.Command.prototype.parse;
+_commander.Command.prototype.parse = function (args, env) {
+  this._parse(args);
+  // Parse the environment first
+  const envOptions = parseEnvironment(env);
+  const fromFile = parseConfigFile(this);
+  // Load the env if not passed from command line
+  this.setValuesIfNeeded(envOptions);
+  // Load from file to override
+  this.setValuesIfNeeded(fromFile);
+  // Scan for deprecated Parse Server options
+  _Deprecator.default.scanParseServerOptions(this);
+  // Last set the defaults
+  this.setValuesIfNeeded(_defaults);
+};
+_commander.Command.prototype.getOptions = function () {
+  return Object.keys(_definitions).reduce((options, key) => {
+    if (typeof this[key] !== 'undefined') {
+      options[key] = this[key];
+    }
+    return options;
+  }, {});
+};
+const commander = new _commander.Command();
+commander.storeOptionsAsProperties();
+commander.allowExcessArguments();
+var _default = exports.default = commander;
+/* eslint-enable no-console */
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_commander","require","_path","_interopRequireDefault","_Deprecator","e","__esModule","default","_definitions","_reverseDefinitions","_defaults","Command","prototype","loadDefinitions","definitions","Object","keys","reduce","program","opt","additionalOptions","required","option","help","action","object","key","value","env","defs","undefined","on","console","log","forEach","parseEnvironment","options","originalKey","parseConfigFile","args","length","jsonPath","path","resolve","jsonConfig","apps","setValuesIfNeeded","hasOwnProperty","call","_parse","parse","envOptions","fromFile","Deprecator","scanParseServerOptions","getOptions","commander","storeOptionsAsProperties","allowExcessArguments","_default","exports"],"sources":["../../../src/cli/utils/commander.js"],"sourcesContent":["/* eslint-disable no-console */\nimport { Command } from 'commander';\nimport path from 'path';\nimport Deprecator from '../../Deprecator/Deprecator';\n\nlet _definitions;\nlet _reverseDefinitions;\nlet _defaults;\n\nCommand.prototype.loadDefinitions = function (definitions) {\n  _definitions = definitions;\n\n  Object.keys(definitions).reduce((program, opt) => {\n    if (typeof definitions[opt] == 'object') {\n      const additionalOptions = definitions[opt];\n      if (additionalOptions.required === true) {\n        return program.option(\n          `--${opt} <${opt}>`,\n          additionalOptions.help,\n          additionalOptions.action\n        );\n      } else {\n        return program.option(\n          `--${opt} [${opt}]`,\n          additionalOptions.help,\n          additionalOptions.action\n        );\n      }\n    }\n    return program.option(`--${opt} [${opt}]`);\n  }, this);\n\n  _reverseDefinitions = Object.keys(definitions).reduce((object, key) => {\n    let value = definitions[key];\n    if (typeof value == 'object') {\n      value = value.env;\n    }\n    if (value) {\n      object[value] = key;\n    }\n    return object;\n  }, {});\n\n  _defaults = Object.keys(definitions).reduce((defs, opt) => {\n    if (_definitions[opt].default !== undefined) {\n      defs[opt] = _definitions[opt].default;\n    }\n    return defs;\n  }, {});\n\n  /* istanbul ignore next */\n  this.on('--help', function () {\n    console.log('  Configure From Environment:');\n    console.log('');\n    Object.keys(_reverseDefinitions).forEach(key => {\n      console.log(`    $ ${key}='${_reverseDefinitions[key]}'`);\n    });\n    console.log('');\n  });\n};\n\nfunction parseEnvironment(env = {}) {\n  return Object.keys(_reverseDefinitions).reduce((options, key) => {\n    if (env[key]) {\n      const originalKey = _reverseDefinitions[key];\n      let action = option => option;\n      if (typeof _definitions[originalKey] === 'object') {\n        action = _definitions[originalKey].action || action;\n      }\n      options[_reverseDefinitions[key]] = action(env[key]);\n    }\n    return options;\n  }, {});\n}\n\nfunction parseConfigFile(program) {\n  let options = {};\n  if (program.args.length > 0) {\n    let jsonPath = program.args[0];\n    jsonPath = path.resolve(jsonPath);\n    const jsonConfig = require(jsonPath);\n    if (jsonConfig.apps) {\n      if (jsonConfig.apps.length > 1) {\n        throw 'Multiple apps are not supported';\n      }\n      options = jsonConfig.apps[0];\n    } else {\n      options = jsonConfig;\n    }\n    Object.keys(options).forEach(key => {\n      const value = options[key];\n      if (!_definitions[key]) {\n        throw `error: unknown option ${key}`;\n      }\n      const action = _definitions[key].action;\n      if (action) {\n        options[key] = action(value);\n      }\n    });\n    console.log(`Configuration loaded from ${jsonPath}`);\n  }\n  return options;\n}\n\nCommand.prototype.setValuesIfNeeded = function (options) {\n  Object.keys(options).forEach(key => {\n    if (!Object.prototype.hasOwnProperty.call(this, key)) {\n      this[key] = options[key];\n    }\n  });\n};\n\nCommand.prototype._parse = Command.prototype.parse;\n\nCommand.prototype.parse = function (args, env) {\n  this._parse(args);\n  // Parse the environment first\n  const envOptions = parseEnvironment(env);\n  const fromFile = parseConfigFile(this);\n  // Load the env if not passed from command line\n  this.setValuesIfNeeded(envOptions);\n  // Load from file to override\n  this.setValuesIfNeeded(fromFile);\n  // Scan for deprecated Parse Server options\n  Deprecator.scanParseServerOptions(this);\n  // Last set the defaults\n  this.setValuesIfNeeded(_defaults);\n};\n\nCommand.prototype.getOptions = function () {\n  return Object.keys(_definitions).reduce((options, key) => {\n    if (typeof this[key] !== 'undefined') {\n      options[key] = this[key];\n    }\n    return options;\n  }, {});\n};\n\nconst commander = new Command()\ncommander.storeOptionsAsProperties();\ncommander.allowExcessArguments();\nexport default commander;\n/* eslint-enable no-console */\n"],"mappings":"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","ignoreList":[]}

package/lib/cli/utils/runner.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _commander = _interopRequireDefault(require("./commander"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function logStartupOptions(options) {
+  if (!options.verbose) {
+    return;
+  }
+  // Keys that may include sensitive information that will be redacted in logs
+  const keysToRedact = ['databaseAdapter', 'databaseURI', 'masterKey', 'maintenanceKey', 'push'];
+  for (const key in options) {
+    let value = options[key];
+    if (keysToRedact.includes(key)) {
+      value = '<REDACTED>';
+    }
+    if (typeof value === 'object') {
+      try {
+        value = JSON.stringify(value);
+      } catch {
+        if (value && value.constructor && value.constructor.name) {
+          value = value.constructor.name;
+        }
+      }
+    }
+    /* eslint-disable no-console */
+    console.log(`${key}: ${value}`);
+    /* eslint-enable no-console */
+  }
+}
+function _default({
+  definitions,
+  help,
+  usage,
+  start
+}) {
+  _commander.default.loadDefinitions(definitions);
+  if (usage) {
+    _commander.default.usage(usage);
+  }
+  if (help) {
+    _commander.default.on('--help', help);
+  }
+  _commander.default.parse(process.argv, process.env);
+  const options = _commander.default.getOptions();
+  start(_commander.default, options, function () {
+    logStartupOptions(options);
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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