parse-server 2.8.4 → 8.6.2

package/lib/GraphQL/ParseGraphQLServer.js

@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParseGraphQLServer = void 0;
+var _cors = _interopRequireDefault(require("cors"));
+var _graphqlUploadExpress = _interopRequireDefault(require("graphql-upload/graphqlUploadExpress.js"));
+var _server = require("@apollo/server");
+var _express = require("@apollo/server/express4");
+var _disabled = require("@apollo/server/plugin/disabled");
+var _express2 = _interopRequireDefault(require("express"));
+var _graphql = require("graphql");
+var _subscriptionsTransportWs = require("subscriptions-transport-ws");
+var _middlewares = require("../middlewares");
+var _requiredParameter = _interopRequireDefault(require("../requiredParameter"));
+var _logger = _interopRequireDefault(require("../logger"));
+var _ParseGraphQLSchema = require("./ParseGraphQLSchema");
+var _ParseGraphQLController = _interopRequireWildcard(require("../Controllers/ParseGraphQLController"));
+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 }; }
+const IntrospectionControlPlugin = publicIntrospection => ({
+  requestDidStart: requestContext => ({
+    didResolveOperation: async () => {
+      // If public introspection is enabled, we allow all introspection queries
+      if (publicIntrospection) {
+        return;
+      }
+      const isMasterOrMaintenance = requestContext.contextValue.auth?.isMaster || requestContext.contextValue.auth?.isMaintenance;
+      if (isMasterOrMaintenance) {
+        return;
+      }
+
+      // Now we check if the query is an introspection query
+      // this check strategy should work in 99.99% cases
+      // we can have an issue if a user name a field or class __schemaSomething
+      // we want to avoid a full AST check
+      const isIntrospectionQuery = requestContext.request.query?.includes('__schema');
+      if (isIntrospectionQuery) {
+        throw new _graphql.GraphQLError('Introspection is not allowed', {
+          extensions: {
+            http: {
+              status: 403
+            }
+          }
+        });
+      }
+    }
+  })
+});
+class ParseGraphQLServer {
+  constructor(parseServer, config) {
+    this.parseServer = parseServer || (0, _requiredParameter.default)('You must provide a parseServer instance!');
+    if (!config || !config.graphQLPath) {
+      (0, _requiredParameter.default)('You must provide a config.graphQLPath!');
+    }
+    this.config = config;
+    this.parseGraphQLController = this.parseServer.config.parseGraphQLController;
+    this.log = this.parseServer.config && this.parseServer.config.loggerController || _logger.default;
+    this.parseGraphQLSchema = new _ParseGraphQLSchema.ParseGraphQLSchema({
+      parseGraphQLController: this.parseGraphQLController,
+      databaseController: this.parseServer.config.databaseController,
+      log: this.log,
+      graphQLCustomTypeDefs: this.config.graphQLCustomTypeDefs,
+      appId: this.parseServer.config.appId
+    });
+  }
+  async _getGraphQLOptions() {
+    try {
+      return {
+        schema: await this.parseGraphQLSchema.load(),
+        context: async ({
+          req,
+          res
+        }) => {
+          res.set('access-control-allow-origin', req.get('origin') || '*');
+          return {
+            info: req.info,
+            config: req.config,
+            auth: req.auth
+          };
+        }
+      };
+    } catch (e) {
+      this.log.error(e.stack || typeof e.toString === 'function' && e.toString() || e);
+      throw e;
+    }
+  }
+  async _getServer() {
+    const schemaRef = this.parseGraphQLSchema.graphQLSchema;
+    const newSchemaRef = await this.parseGraphQLSchema.load();
+    if (schemaRef === newSchemaRef && this._server) {
+      return this._server;
+    }
+    // It means a parallel _getServer call is already in progress
+    if (this._schemaRefMutex === newSchemaRef) {
+      return this._server;
+    }
+    // Update the schema ref mutex to avoid parallel _getServer calls
+    this._schemaRefMutex = newSchemaRef;
+    const createServer = async () => {
+      try {
+        const {
+          schema,
+          context
+        } = await this._getGraphQLOptions();
+        const apollo = new _server.ApolloServer({
+          csrfPrevention: {
+            // See https://www.apollographql.com/docs/router/configuration/csrf/
+            // needed since we use graphql upload
+            requestHeaders: ['X-Parse-Application-Id']
+          },
+          introspection: this.config.graphQLPublicIntrospection,
+          plugins: [(0, _disabled.ApolloServerPluginCacheControlDisabled)(), IntrospectionControlPlugin(this.config.graphQLPublicIntrospection)],
+          schema
+        });
+        await apollo.start();
+        return (0, _express.expressMiddleware)(apollo, {
+          context
+        });
+      } catch (e) {
+        // Reset all mutexes and forward the error
+        this._server = null;
+        this._schemaRefMutex = null;
+        throw e;
+      }
+    };
+    // Do not await so parallel request will wait the same promise ref
+    this._server = createServer();
+    return this._server;
+  }
+  _transformMaxUploadSizeToBytes(maxUploadSize) {
+    const unitMap = {
+      kb: 1,
+      mb: 2,
+      gb: 3
+    };
+    return Number(maxUploadSize.slice(0, -2)) * Math.pow(1024, unitMap[maxUploadSize.slice(-2).toLowerCase()]);
+  }
+
+  /**
+   * @static
+   * Allow developers to customize each request with inversion of control/dependency injection
+   */
+  applyRequestContextMiddleware(api, options) {
+    if (options.requestContextMiddleware) {
+      if (typeof options.requestContextMiddleware !== 'function') {
+        throw new Error('requestContextMiddleware must be a function');
+      }
+      api.use(this.config.graphQLPath, options.requestContextMiddleware);
+    }
+  }
+  applyGraphQL(app) {
+    if (!app || !app.use) {
+      (0, _requiredParameter.default)('You must provide an Express.js app instance!');
+    }
+    app.use(this.config.graphQLPath, (0, _cors.default)());
+    app.use(this.config.graphQLPath, _middlewares.handleParseHeaders);
+    app.use(this.config.graphQLPath, _middlewares.handleParseSession);
+    this.applyRequestContextMiddleware(app, this.parseServer.config);
+    app.use(this.config.graphQLPath, _middlewares.handleParseErrors);
+    app.use(this.config.graphQLPath, (0, _graphqlUploadExpress.default)({
+      maxFileSize: this._transformMaxUploadSizeToBytes(this.parseServer.config.maxUploadSize || '20mb')
+    }));
+    app.use(this.config.graphQLPath, _express2.default.json(), async (req, res, next) => {
+      const server = await this._getServer();
+      return server(req, res, next);
+    });
+  }
+  applyPlayground(app) {
+    if (!app || !app.get) {
+      (0, _requiredParameter.default)('You must provide an Express.js app instance!');
+    }
+    app.get(this.config.playgroundPath || (0, _requiredParameter.default)('You must provide a config.playgroundPath to applyPlayground!'), (_req, res) => {
+      res.setHeader('Content-Type', 'text/html');
+      res.write(`<div id="sandbox" style="position:absolute;top:0;right:0;bottom:0;left:0"></div>
+          <script src="https://embeddable-sandbox.cdn.apollographql.com/_latest/embeddable-sandbox.umd.production.min.js"></script>
+          <script>
+           new window.EmbeddedSandbox({
+             target: "#sandbox",
+             endpointIsEditable: false,
+             initialEndpoint: ${JSON.stringify(this.config.graphQLPath)},
+             handleRequest: (endpointUrl, options) => {
+              return fetch(endpointUrl, {
+                ...options,
+                headers: {
+                    ...options.headers,
+                    'X-Parse-Application-Id': ${JSON.stringify(this.parseServer.config.appId)},
+                    'X-Parse-Master-Key': ${JSON.stringify(this.parseServer.config.masterKey)},
+                },
+              })
+            },
+           });
+           // advanced options: https://www.apollographql.com/docs/studio/explorer/sandbox#embedding-sandbox
+          </script>`);
+      res.end();
+    });
+  }
+  createSubscriptions(server) {
+    _subscriptionsTransportWs.SubscriptionServer.create({
+      execute: _graphql.execute,
+      subscribe: _graphql.subscribe,
+      onOperation: async (_message, params, webSocket) => Object.assign({}, params, await this._getGraphQLOptions(webSocket.upgradeReq))
+    }, {
+      server,
+      path: this.config.subscriptionsPath || (0, _requiredParameter.default)('You must provide a config.subscriptionsPath to createSubscriptions!')
+    });
+  }
+  setGraphQLConfig(graphQLConfig) {
+    return this.parseGraphQLController.updateGraphQLConfig(graphQLConfig);
+  }
+}
+exports.ParseGraphQLServer = ParseGraphQLServer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cors","_interopRequireDefault","require","_graphqlUploadExpress","_server","_express","_disabled","_express2","_graphql","_subscriptionsTransportWs","_middlewares","_requiredParameter","_logger","_ParseGraphQLSchema","_ParseGraphQLController","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","IntrospectionControlPlugin","publicIntrospection","requestDidStart","requestContext","didResolveOperation","isMasterOrMaintenance","contextValue","auth","isMaster","isMaintenance","isIntrospectionQuery","request","query","includes","GraphQLError","extensions","http","status","ParseGraphQLServer","constructor","parseServer","config","requiredParameter","graphQLPath","parseGraphQLController","log","loggerController","defaultLogger","parseGraphQLSchema","ParseGraphQLSchema","databaseController","graphQLCustomTypeDefs","appId","_getGraphQLOptions","schema","load","context","req","res","info","error","stack","toString","_getServer","schemaRef","graphQLSchema","newSchemaRef","_schemaRefMutex","createServer","apollo","ApolloServer","csrfPrevention","requestHeaders","introspection","graphQLPublicIntrospection","plugins","ApolloServerPluginCacheControlDisabled","start","expressMiddleware","_transformMaxUploadSizeToBytes","maxUploadSize","unitMap","kb","mb","gb","Number","slice","Math","pow","toLowerCase","applyRequestContextMiddleware","api","options","requestContextMiddleware","Error","use","applyGraphQL","app","corsMiddleware","handleParseHeaders","handleParseSession","handleParseErrors","graphqlUploadExpress","maxFileSize","express","json","next","server","applyPlayground","playgroundPath","_req","setHeader","write","JSON","stringify","masterKey","end","createSubscriptions","SubscriptionServer","create","execute","subscribe","onOperation","_message","params","webSocket","assign","upgradeReq","path","subscriptionsPath","setGraphQLConfig","graphQLConfig","updateGraphQLConfig","exports"],"sources":["../../src/GraphQL/ParseGraphQLServer.js"],"sourcesContent":["import corsMiddleware from 'cors';\nimport graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.js';\nimport { ApolloServer } from '@apollo/server';\nimport { expressMiddleware } from '@apollo/server/express4';\nimport { ApolloServerPluginCacheControlDisabled } from '@apollo/server/plugin/disabled';\nimport express from 'express';\nimport { execute, subscribe, GraphQLError } from 'graphql';\nimport { SubscriptionServer } from 'subscriptions-transport-ws';\nimport { handleParseErrors, handleParseHeaders, handleParseSession } from '../middlewares';\nimport requiredParameter from '../requiredParameter';\nimport defaultLogger from '../logger';\nimport { ParseGraphQLSchema } from './ParseGraphQLSchema';\nimport ParseGraphQLController, { ParseGraphQLConfig } from '../Controllers/ParseGraphQLController';\n\n\nconst IntrospectionControlPlugin = (publicIntrospection) => ({\n\n\n  requestDidStart: (requestContext) => ({\n\n    didResolveOperation: async () => {\n      // If public introspection is enabled, we allow all introspection queries\n      if (publicIntrospection) {\n        return;\n      }\n\n      const isMasterOrMaintenance = requestContext.contextValue.auth?.isMaster || requestContext.contextValue.auth?.isMaintenance\n      if (isMasterOrMaintenance) {\n        return;\n      }\n\n      // Now we check if the query is an introspection query\n      // this check strategy should work in 99.99% cases\n      // we can have an issue if a user name a field or class __schemaSomething\n      // we want to avoid a full AST check\n      const isIntrospectionQuery =\n        requestContext.request.query?.includes('__schema')\n\n      if (isIntrospectionQuery) {\n        throw new GraphQLError('Introspection is not allowed', {\n          extensions: {\n            http: {\n              status: 403,\n            },\n          }\n        });\n      }\n    },\n\n  })\n\n});\n\nclass ParseGraphQLServer {\n  parseGraphQLController: ParseGraphQLController;\n\n  constructor(parseServer, config) {\n    this.parseServer = parseServer || requiredParameter('You must provide a parseServer instance!');\n    if (!config || !config.graphQLPath) {\n      requiredParameter('You must provide a config.graphQLPath!');\n    }\n    this.config = config;\n    this.parseGraphQLController = this.parseServer.config.parseGraphQLController;\n    this.log =\n      (this.parseServer.config && this.parseServer.config.loggerController) || defaultLogger;\n    this.parseGraphQLSchema = new ParseGraphQLSchema({\n      parseGraphQLController: this.parseGraphQLController,\n      databaseController: this.parseServer.config.databaseController,\n      log: this.log,\n      graphQLCustomTypeDefs: this.config.graphQLCustomTypeDefs,\n      appId: this.parseServer.config.appId,\n    });\n  }\n\n  async _getGraphQLOptions() {\n    try {\n      return {\n        schema: await this.parseGraphQLSchema.load(),\n        context: async ({ req, res }) => {\n          res.set('access-control-allow-origin', req.get('origin') || '*');\n          return {\n            info: req.info,\n            config: req.config,\n            auth: req.auth,\n          };\n        },\n      };\n    } catch (e) {\n      this.log.error(e.stack || (typeof e.toString === 'function' && e.toString()) || e);\n      throw e;\n    }\n  }\n\n  async _getServer() {\n    const schemaRef = this.parseGraphQLSchema.graphQLSchema;\n    const newSchemaRef = await this.parseGraphQLSchema.load();\n    if (schemaRef === newSchemaRef && this._server) {\n      return this._server;\n    }\n    // It means a parallel _getServer call is already in progress\n    if (this._schemaRefMutex === newSchemaRef) {\n      return this._server;\n    }\n    // Update the schema ref mutex to avoid parallel _getServer calls\n    this._schemaRefMutex = newSchemaRef;\n    const createServer = async () => {\n      try {\n        const { schema, context } = await this._getGraphQLOptions();\n        const apollo = new ApolloServer({\n          csrfPrevention: {\n            // See https://www.apollographql.com/docs/router/configuration/csrf/\n            // needed since we use graphql upload\n            requestHeaders: ['X-Parse-Application-Id'],\n          },\n          introspection: this.config.graphQLPublicIntrospection,\n          plugins: [ApolloServerPluginCacheControlDisabled(), IntrospectionControlPlugin(this.config.graphQLPublicIntrospection)],\n          schema,\n        });\n        await apollo.start();\n        return expressMiddleware(apollo, {\n          context,\n        });\n      } catch (e) {\n        // Reset all mutexes and forward the error\n        this._server = null;\n        this._schemaRefMutex = null;\n        throw e;\n      }\n    }\n    // Do not await so parallel request will wait the same promise ref\n    this._server = createServer();\n    return this._server;\n  }\n\n  _transformMaxUploadSizeToBytes(maxUploadSize) {\n    const unitMap = {\n      kb: 1,\n      mb: 2,\n      gb: 3,\n    };\n\n    return (\n      Number(maxUploadSize.slice(0, -2)) *\n      Math.pow(1024, unitMap[maxUploadSize.slice(-2).toLowerCase()])\n    );\n  }\n\n  /**\n   * @static\n   * Allow developers to customize each request with inversion of control/dependency injection\n   */\n  applyRequestContextMiddleware(api, options) {\n    if (options.requestContextMiddleware) {\n      if (typeof options.requestContextMiddleware !== 'function') {\n        throw new Error('requestContextMiddleware must be a function');\n      }\n      api.use(this.config.graphQLPath, options.requestContextMiddleware);\n    }\n  }\n\n  applyGraphQL(app) {\n    if (!app || !app.use) {\n      requiredParameter('You must provide an Express.js app instance!');\n    }\n    app.use(this.config.graphQLPath, corsMiddleware());\n    app.use(this.config.graphQLPath, handleParseHeaders);\n    app.use(this.config.graphQLPath, handleParseSession);\n    this.applyRequestContextMiddleware(app, this.parseServer.config);\n    app.use(this.config.graphQLPath, handleParseErrors);\n    app.use(\n      this.config.graphQLPath,\n      graphqlUploadExpress({\n        maxFileSize: this._transformMaxUploadSizeToBytes(\n          this.parseServer.config.maxUploadSize || '20mb'\n        ),\n      })\n    );\n    app.use(this.config.graphQLPath, express.json(), async (req, res, next) => {\n      const server = await this._getServer();\n      return server(req, res, next);\n    });\n  }\n\n  applyPlayground(app) {\n    if (!app || !app.get) {\n      requiredParameter('You must provide an Express.js app instance!');\n    }\n\n    app.get(\n      this.config.playgroundPath ||\n      requiredParameter('You must provide a config.playgroundPath to applyPlayground!'),\n      (_req, res) => {\n        res.setHeader('Content-Type', 'text/html');\n        res.write(\n          `<div id=\"sandbox\" style=\"position:absolute;top:0;right:0;bottom:0;left:0\"></div>\n          <script src=\"https://embeddable-sandbox.cdn.apollographql.com/_latest/embeddable-sandbox.umd.production.min.js\"></script>\n          <script>\n           new window.EmbeddedSandbox({\n             target: \"#sandbox\",\n             endpointIsEditable: false,\n             initialEndpoint: ${JSON.stringify(this.config.graphQLPath)},\n             handleRequest: (endpointUrl, options) => {\n              return fetch(endpointUrl, {\n                ...options,\n                headers: {\n                    ...options.headers,\n                    'X-Parse-Application-Id': ${JSON.stringify(this.parseServer.config.appId)},\n                    'X-Parse-Master-Key': ${JSON.stringify(this.parseServer.config.masterKey)},\n                },\n              })\n            },\n           });\n           // advanced options: https://www.apollographql.com/docs/studio/explorer/sandbox#embedding-sandbox\n          </script>`\n        );\n        res.end();\n      }\n    );\n  }\n\n  createSubscriptions(server) {\n    SubscriptionServer.create(\n      {\n        execute,\n        subscribe,\n        onOperation: async (_message, params, webSocket) =>\n          Object.assign({}, params, await this._getGraphQLOptions(webSocket.upgradeReq)),\n      },\n      {\n        server,\n        path:\n          this.config.subscriptionsPath ||\n          requiredParameter('You must provide a config.subscriptionsPath to createSubscriptions!'),\n      }\n    );\n  }\n\n  setGraphQLConfig(graphQLConfig: ParseGraphQLConfig): Promise {\n    return this.parseGraphQLController.updateGraphQLConfig(graphQLConfig);\n  }\n}\n\nexport { ParseGraphQLServer };\n"],"mappings":"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","ignoreList":[]}

package/lib/GraphQL/helpers/objectsMutations.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateObject = exports.deleteObject = exports.createObject = void 0;
+var _rest = _interopRequireDefault(require("../../rest"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const createObject = async (className, fields, config, auth, info) => {
+  if (!fields) {
+    fields = {};
+  }
+  return (await _rest.default.create(config, auth, className, fields, info.clientSDK, info.context)).response;
+};
+exports.createObject = createObject;
+const updateObject = async (className, objectId, fields, config, auth, info) => {
+  if (!fields) {
+    fields = {};
+  }
+  return (await _rest.default.update(config, auth, className, {
+    objectId
+  }, fields, info.clientSDK, info.context)).response;
+};
+exports.updateObject = updateObject;
+const deleteObject = async (className, objectId, config, auth, info) => {
+  await _rest.default.del(config, auth, className, objectId, info.context);
+  return true;
+};
+exports.deleteObject = deleteObject;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVzdCIsIl9pbnRlcm9wUmVxdWlyZURlZmF1bHQiLCJyZXF1aXJlIiwiZSIsIl9fZXNNb2R1bGUiLCJkZWZhdWx0IiwiY3JlYXRlT2JqZWN0IiwiY2xhc3NOYW1lIiwiZmllbGRzIiwiY29uZmlnIiwiYXV0aCIsImluZm8iLCJyZXN0IiwiY3JlYXRlIiwiY2xpZW50U0RLIiwiY29udGV4dCIsInJlc3BvbnNlIiwiZXhwb3J0cyIsInVwZGF0ZU9iamVjdCIsIm9iamVjdElkIiwidXBkYXRlIiwiZGVsZXRlT2JqZWN0IiwiZGVsIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL0dyYXBoUUwvaGVscGVycy9vYmplY3RzTXV0YXRpb25zLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCByZXN0IGZyb20gJy4uLy4uL3Jlc3QnO1xuXG5jb25zdCBjcmVhdGVPYmplY3QgPSBhc3luYyAoY2xhc3NOYW1lLCBmaWVsZHMsIGNvbmZpZywgYXV0aCwgaW5mbykgPT4ge1xuICBpZiAoIWZpZWxkcykge1xuICAgIGZpZWxkcyA9IHt9O1xuICB9XG5cbiAgcmV0dXJuIChhd2FpdCByZXN0LmNyZWF0ZShjb25maWcsIGF1dGgsIGNsYXNzTmFtZSwgZmllbGRzLCBpbmZvLmNsaWVudFNESywgaW5mby5jb250ZXh0KSlcbiAgICAucmVzcG9uc2U7XG59O1xuXG5jb25zdCB1cGRhdGVPYmplY3QgPSBhc3luYyAoY2xhc3NOYW1lLCBvYmplY3RJZCwgZmllbGRzLCBjb25maWcsIGF1dGgsIGluZm8pID0+IHtcbiAgaWYgKCFmaWVsZHMpIHtcbiAgICBmaWVsZHMgPSB7fTtcbiAgfVxuXG4gIHJldHVybiAoXG4gICAgYXdhaXQgcmVzdC51cGRhdGUoY29uZmlnLCBhdXRoLCBjbGFzc05hbWUsIHsgb2JqZWN0SWQgfSwgZmllbGRzLCBpbmZvLmNsaWVudFNESywgaW5mby5jb250ZXh0KVxuICApLnJlc3BvbnNlO1xufTtcblxuY29uc3QgZGVsZXRlT2JqZWN0ID0gYXN5bmMgKGNsYXNzTmFtZSwgb2JqZWN0SWQsIGNvbmZpZywgYXV0aCwgaW5mbykgPT4ge1xuICBhd2FpdCByZXN0LmRlbChjb25maWcsIGF1dGgsIGNsYXNzTmFtZSwgb2JqZWN0SWQsIGluZm8uY29udGV4dCk7XG4gIHJldHVybiB0cnVlO1xufTtcblxuZXhwb3J0IHsgY3JlYXRlT2JqZWN0LCB1cGRhdGVPYmplY3QsIGRlbGV0ZU9iamVjdCB9O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxJQUFBQSxLQUFBLEdBQUFDLHNCQUFBLENBQUFDLE9BQUE7QUFBOEIsU0FBQUQsdUJBQUFFLENBQUEsV0FBQUEsQ0FBQSxJQUFBQSxDQUFBLENBQUFDLFVBQUEsR0FBQUQsQ0FBQSxLQUFBRSxPQUFBLEVBQUFGLENBQUE7QUFFOUIsTUFBTUcsWUFBWSxHQUFHLE1BQUFBLENBQU9DLFNBQVMsRUFBRUMsTUFBTSxFQUFFQyxNQUFNLEVBQUVDLElBQUksRUFBRUMsSUFBSSxLQUFLO0VBQ3BFLElBQUksQ0FBQ0gsTUFBTSxFQUFFO0lBQ1hBLE1BQU0sR0FBRyxDQUFDLENBQUM7RUFDYjtFQUVBLE9BQU8sQ0FBQyxNQUFNSSxhQUFJLENBQUNDLE1BQU0sQ0FBQ0osTUFBTSxFQUFFQyxJQUFJLEVBQUVILFNBQVMsRUFBRUMsTUFBTSxFQUFFRyxJQUFJLENBQUNHLFNBQVMsRUFBRUgsSUFBSSxDQUFDSSxPQUFPLENBQUMsRUFDckZDLFFBQVE7QUFDYixDQUFDO0FBQUNDLE9BQUEsQ0FBQVgsWUFBQSxHQUFBQSxZQUFBO0FBRUYsTUFBTVksWUFBWSxHQUFHLE1BQUFBLENBQU9YLFNBQVMsRUFBRVksUUFBUSxFQUFFWCxNQUFNLEVBQUVDLE1BQU0sRUFBRUMsSUFBSSxFQUFFQyxJQUFJLEtBQUs7RUFDOUUsSUFBSSxDQUFDSCxNQUFNLEVBQUU7SUFDWEEsTUFBTSxHQUFHLENBQUMsQ0FBQztFQUNiO0VBRUEsT0FBTyxDQUNMLE1BQU1JLGFBQUksQ0FBQ1EsTUFBTSxDQUFDWCxNQUFNLEVBQUVDLElBQUksRUFBRUgsU0FBUyxFQUFFO0lBQUVZO0VBQVMsQ0FBQyxFQUFFWCxNQUFNLEVBQUVHLElBQUksQ0FBQ0csU0FBUyxFQUFFSCxJQUFJLENBQUNJLE9BQU8sQ0FBQyxFQUM5RkMsUUFBUTtBQUNaLENBQUM7QUFBQ0MsT0FBQSxDQUFBQyxZQUFBLEdBQUFBLFlBQUE7QUFFRixNQUFNRyxZQUFZLEdBQUcsTUFBQUEsQ0FBT2QsU0FBUyxFQUFFWSxRQUFRLEVBQUVWLE1BQU0sRUFBRUMsSUFBSSxFQUFFQyxJQUFJLEtBQUs7RUFDdEUsTUFBTUMsYUFBSSxDQUFDVSxHQUFHLENBQUNiLE1BQU0sRUFBRUMsSUFBSSxFQUFFSCxTQUFTLEVBQUVZLFFBQVEsRUFBRVIsSUFBSSxDQUFDSSxPQUFPLENBQUM7RUFDL0QsT0FBTyxJQUFJO0FBQ2IsQ0FBQztBQUFDRSxPQUFBLENBQUFJLFlBQUEsR0FBQUEsWUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/GraphQL/helpers/objectsQueries.js

@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.needToGetAllKeys = exports.getObject = exports.findObjects = exports.calculateSkipAndLimit = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+var _graphqlRelay = require("graphql-relay");
+var _rest = _interopRequireDefault(require("../../rest"));
+var _query = require("../transformers/query");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Eslint/Prettier conflict
+/* eslint-disable*/
+const needToGetAllKeys = (fields, keys, parseClasses) => keys ? keys.split(',').some(keyName => {
+  const key = keyName.split('.');
+  if (fields[key[0]]) {
+    if (fields[key[0]].type === 'Relation') return false;
+    if (fields[key[0]].type === 'Pointer') {
+      const subClass = parseClasses[fields[key[0]].targetClass];
+      if (subClass && subClass.fields[key[1]]) {
+        // Current sub key is not custom
+        return false;
+      }
+    } else if (!key[1] || fields[key[0]].type === 'Array' || fields[key[0]].type === 'Object') {
+      // current key is not custom
+      return false;
+    }
+  }
+  // Key not found into Parse Schema so it's custom
+  return true;
+}) : true;
+/* eslint-enable*/
+exports.needToGetAllKeys = needToGetAllKeys;
+const getObject = async (className, objectId, keys, include, readPreference, includeReadPreference, config, auth, info, parseClasses) => {
+  const options = {};
+  try {
+    if (!needToGetAllKeys(parseClasses[className].fields, keys, parseClasses)) {
+      options.keys = keys;
+    }
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+  }
+  if (include) {
+    options.include = include;
+    if (includeReadPreference) {
+      options.includeReadPreference = includeReadPreference;
+    }
+  }
+  if (readPreference) {
+    options.readPreference = readPreference;
+  }
+  const response = await _rest.default.get(config, auth, className, objectId, options, info.clientSDK, info.context);
+  if (!response.results || response.results.length == 0) {
+    throw new _node.default.Error(_node.default.Error.OBJECT_NOT_FOUND, 'Object not found.');
+  }
+  const object = response.results[0];
+  if (className === '_User') {
+    delete object.sessionToken;
+  }
+  return object;
+};
+exports.getObject = getObject;
+const findObjects = async (className, where, order, skipInput, first, after, last, before, keys, include, includeAll, readPreference, includeReadPreference, subqueryReadPreference, config, auth, info, selectedFields, parseClasses) => {
+  if (!where) {
+    where = {};
+  }
+  (0, _query.transformQueryInputToParse)(where, className, parseClasses);
+  const skipAndLimitCalculation = calculateSkipAndLimit(skipInput, first, after, last, before, config.maxLimit);
+  let {
+    skip
+  } = skipAndLimitCalculation;
+  const {
+    limit,
+    needToPreCount
+  } = skipAndLimitCalculation;
+  let preCount = undefined;
+  if (needToPreCount) {
+    const preCountOptions = {
+      limit: 0,
+      count: true
+    };
+    if (readPreference) {
+      preCountOptions.readPreference = readPreference;
+    }
+    if (Object.keys(where).length > 0 && subqueryReadPreference) {
+      preCountOptions.subqueryReadPreference = subqueryReadPreference;
+    }
+    preCount = (await _rest.default.find(config, auth, className, where, preCountOptions, info.clientSDK, info.context)).count;
+    if ((skip || 0) + limit < preCount) {
+      skip = preCount - limit;
+    }
+  }
+  const options = {};
+  if (selectedFields.find(field => field.startsWith('edges.') || field.startsWith('pageInfo.'))) {
+    if (limit || limit === 0) {
+      options.limit = limit;
+    } else {
+      options.limit = 100;
+    }
+    if (options.limit !== 0) {
+      if (order) {
+        options.order = order;
+      }
+      if (skip) {
+        options.skip = skip;
+      }
+      if (config.maxLimit && options.limit > config.maxLimit) {
+        // Silently replace the limit on the query with the max configured
+        options.limit = config.maxLimit;
+      }
+      if (!needToGetAllKeys(parseClasses[className].fields, keys, parseClasses)) {
+        options.keys = keys;
+      }
+      if (includeAll === true) {
+        options.includeAll = includeAll;
+      }
+      if (!options.includeAll && include) {
+        options.include = include;
+      }
+      if ((options.includeAll || options.include) && includeReadPreference) {
+        options.includeReadPreference = includeReadPreference;
+      }
+    }
+  } else {
+    options.limit = 0;
+  }
+  if ((selectedFields.includes('count') || selectedFields.includes('pageInfo.hasPreviousPage') || selectedFields.includes('pageInfo.hasNextPage')) && !needToPreCount) {
+    options.count = true;
+  }
+  if (readPreference) {
+    options.readPreference = readPreference;
+  }
+  if (Object.keys(where).length > 0 && subqueryReadPreference) {
+    options.subqueryReadPreference = subqueryReadPreference;
+  }
+  let results, count;
+  if (options.count || !options.limit || options.limit && options.limit > 0) {
+    const findResult = await _rest.default.find(config, auth, className, where, options, info.clientSDK, info.context);
+    results = findResult.results;
+    count = findResult.count;
+  }
+  let edges = null;
+  let pageInfo = null;
+  if (results) {
+    edges = results.map((result, index) => ({
+      cursor: (0, _graphqlRelay.offsetToCursor)((skip || 0) + index),
+      node: result
+    }));
+    pageInfo = {
+      hasPreviousPage: (preCount && preCount > 0 || count && count > 0) && skip !== undefined && skip > 0,
+      startCursor: (0, _graphqlRelay.offsetToCursor)(skip || 0),
+      endCursor: (0, _graphqlRelay.offsetToCursor)((skip || 0) + (results.length || 1) - 1),
+      hasNextPage: (preCount || count) > (skip || 0) + results.length
+    };
+  }
+  return {
+    edges,
+    pageInfo,
+    count: preCount || count
+  };
+};
+exports.findObjects = findObjects;
+const calculateSkipAndLimit = (skipInput, first, after, last, before, maxLimit) => {
+  let skip = undefined;
+  let limit = undefined;
+  let needToPreCount = false;
+
+  // Validates the skip input
+  if (skipInput || skipInput === 0) {
+    if (skipInput < 0) {
+      throw new _node.default.Error(_node.default.Error.INVALID_QUERY, 'Skip should be a positive number');
+    }
+    skip = skipInput;
+  }
+
+  // Validates the after param
+  if (after) {
+    after = (0, _graphqlRelay.cursorToOffset)(after);
+    if (!after && after !== 0 || after < 0) {
+      throw new _node.default.Error(_node.default.Error.INVALID_QUERY, 'After is not a valid cursor');
+    }
+
+    // If skip and after are passed, a new skip is calculated by adding them
+    skip = (skip || 0) + (after + 1);
+  }
+
+  // Validates the first param
+  if (first || first === 0) {
+    if (first < 0) {
+      throw new _node.default.Error(_node.default.Error.INVALID_QUERY, 'First should be a positive number');
+    }
+
+    // The first param is translated to the limit param of the Parse legacy API
+    limit = first;
+  }
+
+  // Validates the before param
+  if (before || before === 0) {
+    // This method converts the cursor to the index of the object
+    before = (0, _graphqlRelay.cursorToOffset)(before);
+    if (!before && before !== 0 || before < 0) {
+      throw new _node.default.Error(_node.default.Error.INVALID_QUERY, 'Before is not a valid cursor');
+    }
+    if ((skip || 0) >= before) {
+      // If the before index is less than the skip, no objects will be returned
+      limit = 0;
+    } else if (!limit && limit !== 0 || (skip || 0) + limit > before) {
+      // If there is no limit set, the limit is calculated. Or, if the limit (plus skip) is bigger than the before index, the new limit is set.
+      limit = before - (skip || 0);
+    }
+  }
+
+  // Validates the last param
+  if (last || last === 0) {
+    if (last < 0) {
+      throw new _node.default.Error(_node.default.Error.INVALID_QUERY, 'Last should be a positive number');
+    }
+    if (last > maxLimit) {
+      // Last can't be bigger than Parse server maxLimit config.
+      last = maxLimit;
+    }
+    if (limit || limit === 0) {
+      // If there is a previous limit set, it may be adjusted
+      if (last < limit) {
+        // if last is less than the current limit
+        skip = (skip || 0) + (limit - last); // The skip is adjusted
+        limit = last; // the limit is adjusted
+      }
+    } else if (last === 0) {
+      // No objects will be returned
+      limit = 0;
+    } else {
+      // No previous limit set, the limit will be equal to last and pre count is needed.
+      limit = last;
+      needToPreCount = true;
+    }
+  }
+  return {
+    skip,
+    limit,
+    needToPreCount
+  };
+};
+exports.calculateSkipAndLimit = calculateSkipAndLimit;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_graphqlRelay","_rest","_query","e","__esModule","default","needToGetAllKeys","fields","keys","parseClasses","split","some","keyName","key","type","subClass","targetClass","exports","getObject","className","objectId","include","readPreference","includeReadPreference","config","auth","info","options","console","error","response","rest","get","clientSDK","context","results","length","Parse","Error","OBJECT_NOT_FOUND","object","sessionToken","findObjects","where","order","skipInput","first","after","last","before","includeAll","subqueryReadPreference","selectedFields","transformQueryInputToParse","skipAndLimitCalculation","calculateSkipAndLimit","maxLimit","skip","limit","needToPreCount","preCount","undefined","preCountOptions","count","Object","find","field","startsWith","includes","findResult","edges","pageInfo","map","result","index","cursor","offsetToCursor","node","hasPreviousPage","startCursor","endCursor","hasNextPage","INVALID_QUERY","cursorToOffset"],"sources":["../../../src/GraphQL/helpers/objectsQueries.js"],"sourcesContent":["import Parse from 'parse/node';\nimport { offsetToCursor, cursorToOffset } from 'graphql-relay';\nimport rest from '../../rest';\nimport { transformQueryInputToParse } from '../transformers/query';\n\n// Eslint/Prettier conflict\n/* eslint-disable*/\nconst needToGetAllKeys = (fields, keys, parseClasses) =>\n  keys\n    ? keys.split(',').some(keyName => {\n        const key = keyName.split('.');\n        if (fields[key[0]]) {\n          if (fields[key[0]].type === 'Relation') return false;\n          if (fields[key[0]].type === 'Pointer') {\n            const subClass = parseClasses[fields[key[0]].targetClass];\n            if (subClass && subClass.fields[key[1]]) {\n              // Current sub key is not custom\n              return false;\n            }\n          } else if (\n            !key[1] ||\n            fields[key[0]].type === 'Array' ||\n            fields[key[0]].type === 'Object'\n          ) {\n            // current key is not custom\n            return false;\n          }\n        }\n        // Key not found into Parse Schema so it's custom\n        return true;\n      })\n    : true;\n/* eslint-enable*/\n\nconst getObject = async (\n  className,\n  objectId,\n  keys,\n  include,\n  readPreference,\n  includeReadPreference,\n  config,\n  auth,\n  info,\n  parseClasses\n) => {\n  const options = {};\n  try {\n    if (!needToGetAllKeys(parseClasses[className].fields, keys, parseClasses)) {\n      options.keys = keys;\n    }\n  } catch (e) {\n    // eslint-disable-next-line no-console\n    console.error(e);\n  }\n  if (include) {\n    options.include = include;\n    if (includeReadPreference) {\n      options.includeReadPreference = includeReadPreference;\n    }\n  }\n  if (readPreference) {\n    options.readPreference = readPreference;\n  }\n\n  const response = await rest.get(\n    config,\n    auth,\n    className,\n    objectId,\n    options,\n    info.clientSDK,\n    info.context\n  );\n\n  if (!response.results || response.results.length == 0) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found.');\n  }\n\n  const object = response.results[0];\n  if (className === '_User') {\n    delete object.sessionToken;\n  }\n  return object;\n};\n\nconst findObjects = async (\n  className,\n  where,\n  order,\n  skipInput,\n  first,\n  after,\n  last,\n  before,\n  keys,\n  include,\n  includeAll,\n  readPreference,\n  includeReadPreference,\n  subqueryReadPreference,\n  config,\n  auth,\n  info,\n  selectedFields,\n  parseClasses\n) => {\n  if (!where) {\n    where = {};\n  }\n  transformQueryInputToParse(where, className, parseClasses);\n  const skipAndLimitCalculation = calculateSkipAndLimit(\n    skipInput,\n    first,\n    after,\n    last,\n    before,\n    config.maxLimit\n  );\n  let { skip } = skipAndLimitCalculation;\n  const { limit, needToPreCount } = skipAndLimitCalculation;\n  let preCount = undefined;\n  if (needToPreCount) {\n    const preCountOptions = {\n      limit: 0,\n      count: true,\n    };\n    if (readPreference) {\n      preCountOptions.readPreference = readPreference;\n    }\n    if (Object.keys(where).length > 0 && subqueryReadPreference) {\n      preCountOptions.subqueryReadPreference = subqueryReadPreference;\n    }\n    preCount = (\n      await rest.find(config, auth, className, where, preCountOptions, info.clientSDK, info.context)\n    ).count;\n    if ((skip || 0) + limit < preCount) {\n      skip = preCount - limit;\n    }\n  }\n\n  const options = {};\n\n  if (selectedFields.find(field => field.startsWith('edges.') || field.startsWith('pageInfo.'))) {\n    if (limit || limit === 0) {\n      options.limit = limit;\n    } else {\n      options.limit = 100;\n    }\n    if (options.limit !== 0) {\n      if (order) {\n        options.order = order;\n      }\n      if (skip) {\n        options.skip = skip;\n      }\n      if (config.maxLimit && options.limit > config.maxLimit) {\n        // Silently replace the limit on the query with the max configured\n        options.limit = config.maxLimit;\n      }\n      if (!needToGetAllKeys(parseClasses[className].fields, keys, parseClasses)) {\n        options.keys = keys;\n      }\n      if (includeAll === true) {\n        options.includeAll = includeAll;\n      }\n      if (!options.includeAll && include) {\n        options.include = include;\n      }\n      if ((options.includeAll || options.include) && includeReadPreference) {\n        options.includeReadPreference = includeReadPreference;\n      }\n    }\n  } else {\n    options.limit = 0;\n  }\n\n  if (\n    (selectedFields.includes('count') ||\n      selectedFields.includes('pageInfo.hasPreviousPage') ||\n      selectedFields.includes('pageInfo.hasNextPage')) &&\n    !needToPreCount\n  ) {\n    options.count = true;\n  }\n\n  if (readPreference) {\n    options.readPreference = readPreference;\n  }\n  if (Object.keys(where).length > 0 && subqueryReadPreference) {\n    options.subqueryReadPreference = subqueryReadPreference;\n  }\n\n  let results, count;\n  if (options.count || !options.limit || (options.limit && options.limit > 0)) {\n    const findResult = await rest.find(\n      config,\n      auth,\n      className,\n      where,\n      options,\n      info.clientSDK,\n      info.context\n    );\n    results = findResult.results;\n    count = findResult.count;\n  }\n\n  let edges = null;\n  let pageInfo = null;\n  if (results) {\n    edges = results.map((result, index) => ({\n      cursor: offsetToCursor((skip || 0) + index),\n      node: result,\n    }));\n\n    pageInfo = {\n      hasPreviousPage:\n        ((preCount && preCount > 0) || (count && count > 0)) && skip !== undefined && skip > 0,\n      startCursor: offsetToCursor(skip || 0),\n      endCursor: offsetToCursor((skip || 0) + (results.length || 1) - 1),\n      hasNextPage: (preCount || count) > (skip || 0) + results.length,\n    };\n  }\n\n  return {\n    edges,\n    pageInfo,\n    count: preCount || count,\n  };\n};\n\nconst calculateSkipAndLimit = (skipInput, first, after, last, before, maxLimit) => {\n  let skip = undefined;\n  let limit = undefined;\n  let needToPreCount = false;\n\n  // Validates the skip input\n  if (skipInput || skipInput === 0) {\n    if (skipInput < 0) {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Skip should be a positive number');\n    }\n    skip = skipInput;\n  }\n\n  // Validates the after param\n  if (after) {\n    after = cursorToOffset(after);\n    if ((!after && after !== 0) || after < 0) {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'After is not a valid cursor');\n    }\n\n    // If skip and after are passed, a new skip is calculated by adding them\n    skip = (skip || 0) + (after + 1);\n  }\n\n  // Validates the first param\n  if (first || first === 0) {\n    if (first < 0) {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'First should be a positive number');\n    }\n\n    // The first param is translated to the limit param of the Parse legacy API\n    limit = first;\n  }\n\n  // Validates the before param\n  if (before || before === 0) {\n    // This method converts the cursor to the index of the object\n    before = cursorToOffset(before);\n    if ((!before && before !== 0) || before < 0) {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Before is not a valid cursor');\n    }\n\n    if ((skip || 0) >= before) {\n      // If the before index is less than the skip, no objects will be returned\n      limit = 0;\n    } else if ((!limit && limit !== 0) || (skip || 0) + limit > before) {\n      // If there is no limit set, the limit is calculated. Or, if the limit (plus skip) is bigger than the before index, the new limit is set.\n      limit = before - (skip || 0);\n    }\n  }\n\n  // Validates the last param\n  if (last || last === 0) {\n    if (last < 0) {\n      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Last should be a positive number');\n    }\n\n    if (last > maxLimit) {\n      // Last can't be bigger than Parse server maxLimit config.\n      last = maxLimit;\n    }\n\n    if (limit || limit === 0) {\n      // If there is a previous limit set, it may be adjusted\n      if (last < limit) {\n        // if last is less than the current limit\n        skip = (skip || 0) + (limit - last); // The skip is adjusted\n        limit = last; // the limit is adjusted\n      }\n    } else if (last === 0) {\n      // No objects will be returned\n      limit = 0;\n    } else {\n      // No previous limit set, the limit will be equal to last and pre count is needed.\n      limit = last;\n      needToPreCount = true;\n    }\n  }\n  return {\n    skip,\n    limit,\n    needToPreCount,\n  };\n};\n\nexport { getObject, findObjects, calculateSkipAndLimit, needToGetAllKeys };\n"],"mappings":"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","ignoreList":[]}