parse-server 2.8.4 → 8.6.2

package/lib/GraphQL/loaders/parseClassTypes.js

@@ -0,0 +1,493 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "extractKeysAndInclude", {
+  enumerable: true,
+  get: function () {
+    return _parseGraphQLUtils.extractKeysAndInclude;
+  }
+});
+exports.load = void 0;
+var _graphql = require("graphql");
+var _graphqlRelay = require("graphql-relay");
+var _graphqlListFields = _interopRequireDefault(require("graphql-list-fields"));
+var defaultGraphQLTypes = _interopRequireWildcard(require("./defaultGraphQLTypes"));
+var objectsQueries = _interopRequireWildcard(require("../helpers/objectsQueries"));
+var _ParseGraphQLController = require("../../Controllers/ParseGraphQLController");
+var _className = require("../transformers/className");
+var _inputType = require("../transformers/inputType");
+var _outputType = require("../transformers/outputType");
+var _constraintType = require("../transformers/constraintType");
+var _parseGraphQLUtils = require("../parseGraphQLUtils");
+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 }; }
+/* eslint-disable indent */
+
+const getParseClassTypeConfig = function (parseClassConfig) {
+  return parseClassConfig && parseClassConfig.type || {};
+};
+const getInputFieldsAndConstraints = function (parseClass, parseClassConfig) {
+  const classFields = Object.keys(parseClass.fields).concat('id');
+  const {
+    inputFields: allowedInputFields,
+    outputFields: allowedOutputFields,
+    constraintFields: allowedConstraintFields,
+    sortFields: allowedSortFields
+  } = getParseClassTypeConfig(parseClassConfig);
+  let classOutputFields;
+  let classCreateFields;
+  let classUpdateFields;
+  let classConstraintFields;
+  let classSortFields;
+
+  // All allowed customs fields
+  const classCustomFields = classFields.filter(field => {
+    return !Object.keys(defaultGraphQLTypes.PARSE_OBJECT_FIELDS).includes(field) && field !== 'id';
+  });
+  if (allowedInputFields && allowedInputFields.create) {
+    classCreateFields = classCustomFields.filter(field => {
+      return allowedInputFields.create.includes(field);
+    });
+  } else {
+    classCreateFields = classCustomFields;
+  }
+  if (allowedInputFields && allowedInputFields.update) {
+    classUpdateFields = classCustomFields.filter(field => {
+      return allowedInputFields.update.includes(field);
+    });
+  } else {
+    classUpdateFields = classCustomFields;
+  }
+  if (allowedOutputFields) {
+    classOutputFields = classCustomFields.filter(field => {
+      return allowedOutputFields.includes(field);
+    });
+  } else {
+    classOutputFields = classCustomFields;
+  }
+  // Filters the "password" field from class _User
+  if (parseClass.className === '_User') {
+    classOutputFields = classOutputFields.filter(outputField => outputField !== 'password');
+  }
+  if (allowedConstraintFields) {
+    classConstraintFields = classCustomFields.filter(field => {
+      return allowedConstraintFields.includes(field);
+    });
+  } else {
+    classConstraintFields = classFields;
+  }
+  if (allowedSortFields) {
+    classSortFields = allowedSortFields;
+    if (!classSortFields.length) {
+      // must have at least 1 order field
+      // otherwise the FindArgs Input Type will throw.
+      classSortFields.push({
+        field: 'id',
+        asc: true,
+        desc: true
+      });
+    }
+  } else {
+    classSortFields = classFields.map(field => {
+      return {
+        field,
+        asc: true,
+        desc: true
+      };
+    });
+  }
+  return {
+    classCreateFields,
+    classUpdateFields,
+    classConstraintFields,
+    classOutputFields,
+    classSortFields
+  };
+};
+const load = (parseGraphQLSchema, parseClass, parseClassConfig) => {
+  const className = parseClass.className;
+  const graphQLClassName = (0, _className.transformClassNameToGraphQL)(className);
+  const {
+    classCreateFields,
+    classUpdateFields,
+    classOutputFields,
+    classConstraintFields,
+    classSortFields
+  } = getInputFieldsAndConstraints(parseClass, parseClassConfig);
+  const {
+    create: isCreateEnabled = true,
+    update: isUpdateEnabled = true
+  } = (0, _parseGraphQLUtils.getParseClassMutationConfig)(parseClassConfig);
+  const classGraphQLCreateTypeName = `Create${graphQLClassName}FieldsInput`;
+  let classGraphQLCreateType = new _graphql.GraphQLInputObjectType({
+    name: classGraphQLCreateTypeName,
+    description: `The ${classGraphQLCreateTypeName} input type is used in operations that involve creation of objects in the ${graphQLClassName} class.`,
+    fields: () => classCreateFields.reduce((fields, field) => {
+      const type = (0, _inputType.transformInputTypeToGraphQL)(parseClass.fields[field].type, parseClass.fields[field].targetClass, parseGraphQLSchema.parseClassTypes);
+      if (type) {
+        return {
+          ...fields,
+          [field]: {
+            description: `This is the object ${field}.`,
+            type: parseClass.fields[field].required ? new _graphql.GraphQLNonNull(type) : type
+          }
+        };
+      } else {
+        return fields;
+      }
+    }, {
+      ACL: {
+        type: defaultGraphQLTypes.ACL_INPUT
+      }
+    })
+  });
+  classGraphQLCreateType = parseGraphQLSchema.addGraphQLType(classGraphQLCreateType);
+  const classGraphQLUpdateTypeName = `Update${graphQLClassName}FieldsInput`;
+  let classGraphQLUpdateType = new _graphql.GraphQLInputObjectType({
+    name: classGraphQLUpdateTypeName,
+    description: `The ${classGraphQLUpdateTypeName} input type is used in operations that involve creation of objects in the ${graphQLClassName} class.`,
+    fields: () => classUpdateFields.reduce((fields, field) => {
+      const type = (0, _inputType.transformInputTypeToGraphQL)(parseClass.fields[field].type, parseClass.fields[field].targetClass, parseGraphQLSchema.parseClassTypes);
+      if (type) {
+        return {
+          ...fields,
+          [field]: {
+            description: `This is the object ${field}.`,
+            type
+          }
+        };
+      } else {
+        return fields;
+      }
+    }, {
+      ACL: {
+        type: defaultGraphQLTypes.ACL_INPUT
+      }
+    })
+  });
+  classGraphQLUpdateType = parseGraphQLSchema.addGraphQLType(classGraphQLUpdateType);
+  const classGraphQLPointerTypeName = `${graphQLClassName}PointerInput`;
+  let classGraphQLPointerType = new _graphql.GraphQLInputObjectType({
+    name: classGraphQLPointerTypeName,
+    description: `Allow to link OR add and link an object of the ${graphQLClassName} class.`,
+    fields: () => {
+      const fields = {
+        link: {
+          description: `Link an existing object from ${graphQLClassName} class. You can use either the global or the object id.`,
+          type: _graphql.GraphQLID
+        }
+      };
+      if (isCreateEnabled) {
+        fields['createAndLink'] = {
+          description: `Create and link an object from ${graphQLClassName} class.`,
+          type: classGraphQLCreateType
+        };
+      }
+      return fields;
+    }
+  });
+  classGraphQLPointerType = parseGraphQLSchema.addGraphQLType(classGraphQLPointerType) || defaultGraphQLTypes.OBJECT;
+  const classGraphQLRelationTypeName = `${graphQLClassName}RelationInput`;
+  let classGraphQLRelationType = new _graphql.GraphQLInputObjectType({
+    name: classGraphQLRelationTypeName,
+    description: `Allow to add, remove, createAndAdd objects of the ${graphQLClassName} class into a relation field.`,
+    fields: () => {
+      const fields = {
+        add: {
+          description: `Add existing objects from the ${graphQLClassName} class into the relation. You can use either the global or the object ids.`,
+          type: new _graphql.GraphQLList(defaultGraphQLTypes.OBJECT_ID)
+        },
+        remove: {
+          description: `Remove existing objects from the ${graphQLClassName} class out of the relation. You can use either the global or the object ids.`,
+          type: new _graphql.GraphQLList(defaultGraphQLTypes.OBJECT_ID)
+        }
+      };
+      if (isCreateEnabled) {
+        fields['createAndAdd'] = {
+          description: `Create and add objects of the ${graphQLClassName} class into the relation.`,
+          type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(classGraphQLCreateType))
+        };
+      }
+      return fields;
+    }
+  });
+  classGraphQLRelationType = parseGraphQLSchema.addGraphQLType(classGraphQLRelationType) || defaultGraphQLTypes.OBJECT;
+  const classGraphQLConstraintsTypeName = `${graphQLClassName}WhereInput`;
+  let classGraphQLConstraintsType = new _graphql.GraphQLInputObjectType({
+    name: classGraphQLConstraintsTypeName,
+    description: `The ${classGraphQLConstraintsTypeName} input type is used in operations that involve filtering objects of ${graphQLClassName} class.`,
+    fields: () => ({
+      ...classConstraintFields.reduce((fields, field) => {
+        if (['OR', 'AND', 'NOR'].includes(field)) {
+          parseGraphQLSchema.log.warn(`Field ${field} could not be added to the auto schema ${classGraphQLConstraintsTypeName} because it collided with an existing one.`);
+          return fields;
+        }
+        const parseField = field === 'id' ? 'objectId' : field;
+        const type = (0, _constraintType.transformConstraintTypeToGraphQL)(parseClass.fields[parseField].type, parseClass.fields[parseField].targetClass, parseGraphQLSchema.parseClassTypes, field);
+        if (type) {
+          return {
+            ...fields,
+            [field]: {
+              description: `This is the object ${field}.`,
+              type
+            }
+          };
+        } else {
+          return fields;
+        }
+      }, {}),
+      OR: {
+        description: 'This is the OR operator to compound constraints.',
+        type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(classGraphQLConstraintsType))
+      },
+      AND: {
+        description: 'This is the AND operator to compound constraints.',
+        type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(classGraphQLConstraintsType))
+      },
+      NOR: {
+        description: 'This is the NOR operator to compound constraints.',
+        type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(classGraphQLConstraintsType))
+      }
+    })
+  });
+  classGraphQLConstraintsType = parseGraphQLSchema.addGraphQLType(classGraphQLConstraintsType) || defaultGraphQLTypes.OBJECT;
+  const classGraphQLRelationConstraintsTypeName = `${graphQLClassName}RelationWhereInput`;
+  let classGraphQLRelationConstraintsType = new _graphql.GraphQLInputObjectType({
+    name: classGraphQLRelationConstraintsTypeName,
+    description: `The ${classGraphQLRelationConstraintsTypeName} input type is used in operations that involve filtering objects of ${graphQLClassName} class.`,
+    fields: () => ({
+      have: {
+        description: 'Run a relational/pointer query where at least one child object can match.',
+        type: classGraphQLConstraintsType
+      },
+      haveNot: {
+        description: 'Run an inverted relational/pointer query where at least one child object can match.',
+        type: classGraphQLConstraintsType
+      },
+      exists: {
+        description: 'Check if the relation/pointer contains objects.',
+        type: _graphql.GraphQLBoolean
+      }
+    })
+  });
+  classGraphQLRelationConstraintsType = parseGraphQLSchema.addGraphQLType(classGraphQLRelationConstraintsType) || defaultGraphQLTypes.OBJECT;
+  const classGraphQLOrderTypeName = `${graphQLClassName}Order`;
+  let classGraphQLOrderType = new _graphql.GraphQLEnumType({
+    name: classGraphQLOrderTypeName,
+    description: `The ${classGraphQLOrderTypeName} input type is used when sorting objects of the ${graphQLClassName} class.`,
+    values: classSortFields.reduce((sortFields, fieldConfig) => {
+      const {
+        field,
+        asc,
+        desc
+      } = fieldConfig;
+      const updatedSortFields = {
+        ...sortFields
+      };
+      const value = field === 'id' ? 'objectId' : field;
+      if (asc) {
+        updatedSortFields[`${field}_ASC`] = {
+          value
+        };
+      }
+      if (desc) {
+        updatedSortFields[`${field}_DESC`] = {
+          value: `-${value}`
+        };
+      }
+      return updatedSortFields;
+    }, {})
+  });
+  classGraphQLOrderType = parseGraphQLSchema.addGraphQLType(classGraphQLOrderType);
+  const classGraphQLFindArgs = {
+    where: {
+      description: 'These are the conditions that the objects need to match in order to be found.',
+      type: classGraphQLConstraintsType
+    },
+    order: {
+      description: 'The fields to be used when sorting the data fetched.',
+      type: classGraphQLOrderType ? new _graphql.GraphQLList(new _graphql.GraphQLNonNull(classGraphQLOrderType)) : _graphql.GraphQLString
+    },
+    skip: defaultGraphQLTypes.SKIP_ATT,
+    ..._graphqlRelay.connectionArgs,
+    options: defaultGraphQLTypes.READ_OPTIONS_ATT
+  };
+  const classGraphQLOutputTypeName = `${graphQLClassName}`;
+  const interfaces = [defaultGraphQLTypes.PARSE_OBJECT, parseGraphQLSchema.relayNodeInterface];
+  const parseObjectFields = {
+    id: (0, _graphqlRelay.globalIdField)(className, obj => obj.objectId),
+    ...defaultGraphQLTypes.PARSE_OBJECT_FIELDS,
+    ...(className === '_User' ? {
+      authDataResponse: {
+        description: `auth provider response when triggered on signUp/logIn.`,
+        type: defaultGraphQLTypes.OBJECT
+      }
+    } : {})
+  };
+  const outputFields = () => {
+    return classOutputFields.reduce((fields, field) => {
+      const type = (0, _outputType.transformOutputTypeToGraphQL)(parseClass.fields[field].type, parseClass.fields[field].targetClass, parseGraphQLSchema.parseClassTypes);
+      if (parseClass.fields[field].type === 'Relation') {
+        const targetParseClassTypes = parseGraphQLSchema.parseClassTypes[parseClass.fields[field].targetClass];
+        const args = targetParseClassTypes ? targetParseClassTypes.classGraphQLFindArgs : undefined;
+        return {
+          ...fields,
+          [field]: {
+            description: `This is the object ${field}.`,
+            args,
+            type: parseClass.fields[field].required ? new _graphql.GraphQLNonNull(type) : type,
+            async resolve(source, args, context, queryInfo) {
+              try {
+                const {
+                  where,
+                  order,
+                  skip,
+                  first,
+                  after,
+                  last,
+                  before,
+                  options
+                } = args;
+                const {
+                  readPreference,
+                  includeReadPreference,
+                  subqueryReadPreference
+                } = options || {};
+                const {
+                  config,
+                  auth,
+                  info
+                } = context;
+                const selectedFields = (0, _graphqlListFields.default)(queryInfo);
+                const {
+                  keys,
+                  include
+                } = (0, _parseGraphQLUtils.extractKeysAndInclude)(selectedFields.filter(field => field.startsWith('edges.node.')).map(field => field.replace('edges.node.', '')).filter(field => field.indexOf('edges.node') < 0));
+                const parseOrder = order && order.join(',');
+                return objectsQueries.findObjects(source[field].className, {
+                  $relatedTo: {
+                    object: {
+                      __type: 'Pointer',
+                      className: className,
+                      objectId: source.objectId
+                    },
+                    key: field
+                  },
+                  ...(where || {})
+                }, parseOrder, skip, first, after, last, before, keys, include, false, readPreference, includeReadPreference, subqueryReadPreference, config, auth, info, selectedFields, parseGraphQLSchema.parseClasses);
+              } catch (e) {
+                parseGraphQLSchema.handleError(e);
+              }
+            }
+          }
+        };
+      } else if (parseClass.fields[field].type === 'Polygon') {
+        return {
+          ...fields,
+          [field]: {
+            description: `This is the object ${field}.`,
+            type: parseClass.fields[field].required ? new _graphql.GraphQLNonNull(type) : type,
+            async resolve(source) {
+              if (source[field] && source[field].coordinates) {
+                return source[field].coordinates.map(coordinate => ({
+                  latitude: coordinate[0],
+                  longitude: coordinate[1]
+                }));
+              } else {
+                return null;
+              }
+            }
+          }
+        };
+      } else if (parseClass.fields[field].type === 'Array') {
+        return {
+          ...fields,
+          [field]: {
+            description: `Use Inline Fragment on Array to get results: https://graphql.org/learn/queries/#inline-fragments`,
+            type: parseClass.fields[field].required ? new _graphql.GraphQLNonNull(type) : type,
+            async resolve(source) {
+              if (!source[field]) {
+                return null;
+              }
+              return source[field].map(async elem => {
+                if (elem.className && elem.objectId && elem.__type === 'Object') {
+                  return elem;
+                } else {
+                  return {
+                    value: elem
+                  };
+                }
+              });
+            }
+          }
+        };
+      } else if (type) {
+        return {
+          ...fields,
+          [field]: {
+            description: `This is the object ${field}.`,
+            type: parseClass.fields[field].required ? new _graphql.GraphQLNonNull(type) : type
+          }
+        };
+      } else {
+        return fields;
+      }
+    }, parseObjectFields);
+  };
+  let classGraphQLOutputType = new _graphql.GraphQLObjectType({
+    name: classGraphQLOutputTypeName,
+    description: `The ${classGraphQLOutputTypeName} object type is used in operations that involve outputting objects of ${graphQLClassName} class.`,
+    interfaces,
+    fields: outputFields
+  });
+  classGraphQLOutputType = parseGraphQLSchema.addGraphQLType(classGraphQLOutputType);
+  const {
+    connectionType,
+    edgeType
+  } = (0, _graphqlRelay.connectionDefinitions)({
+    name: graphQLClassName,
+    connectionFields: {
+      count: defaultGraphQLTypes.COUNT_ATT
+    },
+    nodeType: classGraphQLOutputType || defaultGraphQLTypes.OBJECT
+  });
+  let classGraphQLFindResultType = undefined;
+  if (parseGraphQLSchema.addGraphQLType(edgeType) && parseGraphQLSchema.addGraphQLType(connectionType, false, false, true)) {
+    classGraphQLFindResultType = connectionType;
+  }
+  parseGraphQLSchema.parseClassTypes[className] = {
+    classGraphQLPointerType,
+    classGraphQLRelationType,
+    classGraphQLCreateType,
+    classGraphQLUpdateType,
+    classGraphQLConstraintsType,
+    classGraphQLRelationConstraintsType,
+    classGraphQLFindArgs,
+    classGraphQLOutputType,
+    classGraphQLFindResultType,
+    config: {
+      parseClassConfig,
+      isCreateEnabled,
+      isUpdateEnabled
+    }
+  };
+  if (className === '_User') {
+    const viewerType = new _graphql.GraphQLObjectType({
+      name: 'Viewer',
+      description: `The Viewer object type is used in operations that involve outputting the current user data.`,
+      fields: () => ({
+        sessionToken: defaultGraphQLTypes.SESSION_TOKEN_ATT,
+        user: {
+          description: 'This is the current user.',
+          type: new _graphql.GraphQLNonNull(classGraphQLOutputType)
+        }
+      })
+    });
+    parseGraphQLSchema.addGraphQLType(viewerType, true, true);
+    parseGraphQLSchema.viewerType = viewerType;
+  }
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_graphql","require","_graphqlRelay","_graphqlListFields","_interopRequireDefault","defaultGraphQLTypes","_interopRequireWildcard","objectsQueries","_ParseGraphQLController","_className","_inputType","_outputType","_constraintType","_parseGraphQLUtils","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","getParseClassTypeConfig","parseClassConfig","type","getInputFieldsAndConstraints","parseClass","classFields","keys","fields","concat","inputFields","allowedInputFields","outputFields","allowedOutputFields","constraintFields","allowedConstraintFields","sortFields","allowedSortFields","classOutputFields","classCreateFields","classUpdateFields","classConstraintFields","classSortFields","classCustomFields","filter","field","PARSE_OBJECT_FIELDS","includes","create","update","className","outputField","length","push","asc","desc","map","load","parseGraphQLSchema","graphQLClassName","transformClassNameToGraphQL","isCreateEnabled","isUpdateEnabled","getParseClassMutationConfig","classGraphQLCreateTypeName","classGraphQLCreateType","GraphQLInputObjectType","name","description","reduce","transformInputTypeToGraphQL","targetClass","parseClassTypes","required","GraphQLNonNull","ACL","ACL_INPUT","addGraphQLType","classGraphQLUpdateTypeName","classGraphQLUpdateType","classGraphQLPointerTypeName","classGraphQLPointerType","link","GraphQLID","OBJECT","classGraphQLRelationTypeName","classGraphQLRelationType","add","GraphQLList","OBJECT_ID","remove","classGraphQLConstraintsTypeName","classGraphQLConstraintsType","log","warn","parseField","transformConstraintTypeToGraphQL","OR","AND","NOR","classGraphQLRelationConstraintsTypeName","classGraphQLRelationConstraintsType","have","haveNot","exists","GraphQLBoolean","classGraphQLOrderTypeName","classGraphQLOrderType","GraphQLEnumType","values","fieldConfig","updatedSortFields","value","classGraphQLFindArgs","where","order","GraphQLString","skip","SKIP_ATT","connectionArgs","options","READ_OPTIONS_ATT","classGraphQLOutputTypeName","interfaces","PARSE_OBJECT","relayNodeInterface","parseObjectFields","id","globalIdField","obj","objectId","authDataResponse","transformOutputTypeToGraphQL","targetParseClassTypes","args","undefined","resolve","source","context","queryInfo","first","after","last","before","readPreference","includeReadPreference","subqueryReadPreference","config","auth","info","selectedFields","getFieldNames","include","extractKeysAndInclude","startsWith","replace","indexOf","parseOrder","join","findObjects","$relatedTo","object","__type","key","parseClasses","handleError","coordinates","coordinate","latitude","longitude","elem","classGraphQLOutputType","GraphQLObjectType","connectionType","edgeType","connectionDefinitions","connectionFields","count","COUNT_ATT","nodeType","classGraphQLFindResultType","viewerType","sessionToken","SESSION_TOKEN_ATT","user","exports"],"sources":["../../../src/GraphQL/loaders/parseClassTypes.js"],"sourcesContent":["/* eslint-disable indent */\nimport {\n  GraphQLID,\n  GraphQLObjectType,\n  GraphQLString,\n  GraphQLList,\n  GraphQLInputObjectType,\n  GraphQLNonNull,\n  GraphQLBoolean,\n  GraphQLEnumType,\n} from 'graphql';\nimport { globalIdField, connectionArgs, connectionDefinitions } from 'graphql-relay';\nimport getFieldNames from 'graphql-list-fields';\nimport * as defaultGraphQLTypes from './defaultGraphQLTypes';\nimport * as objectsQueries from '../helpers/objectsQueries';\nimport { ParseGraphQLClassConfig } from '../../Controllers/ParseGraphQLController';\nimport { transformClassNameToGraphQL } from '../transformers/className';\nimport { transformInputTypeToGraphQL } from '../transformers/inputType';\nimport { transformOutputTypeToGraphQL } from '../transformers/outputType';\nimport { transformConstraintTypeToGraphQL } from '../transformers/constraintType';\nimport { extractKeysAndInclude, getParseClassMutationConfig } from '../parseGraphQLUtils';\n\nconst getParseClassTypeConfig = function (parseClassConfig: ?ParseGraphQLClassConfig) {\n  return (parseClassConfig && parseClassConfig.type) || {};\n};\n\nconst getInputFieldsAndConstraints = function (\n  parseClass,\n  parseClassConfig: ?ParseGraphQLClassConfig\n) {\n  const classFields = Object.keys(parseClass.fields).concat('id');\n  const {\n    inputFields: allowedInputFields,\n    outputFields: allowedOutputFields,\n    constraintFields: allowedConstraintFields,\n    sortFields: allowedSortFields,\n  } = getParseClassTypeConfig(parseClassConfig);\n\n  let classOutputFields;\n  let classCreateFields;\n  let classUpdateFields;\n  let classConstraintFields;\n  let classSortFields;\n\n  // All allowed customs fields\n  const classCustomFields = classFields.filter(field => {\n    return !Object.keys(defaultGraphQLTypes.PARSE_OBJECT_FIELDS).includes(field) && field !== 'id';\n  });\n\n  if (allowedInputFields && allowedInputFields.create) {\n    classCreateFields = classCustomFields.filter(field => {\n      return allowedInputFields.create.includes(field);\n    });\n  } else {\n    classCreateFields = classCustomFields;\n  }\n  if (allowedInputFields && allowedInputFields.update) {\n    classUpdateFields = classCustomFields.filter(field => {\n      return allowedInputFields.update.includes(field);\n    });\n  } else {\n    classUpdateFields = classCustomFields;\n  }\n\n  if (allowedOutputFields) {\n    classOutputFields = classCustomFields.filter(field => {\n      return allowedOutputFields.includes(field);\n    });\n  } else {\n    classOutputFields = classCustomFields;\n  }\n  // Filters the \"password\" field from class _User\n  if (parseClass.className === '_User') {\n    classOutputFields = classOutputFields.filter(outputField => outputField !== 'password');\n  }\n\n  if (allowedConstraintFields) {\n    classConstraintFields = classCustomFields.filter(field => {\n      return allowedConstraintFields.includes(field);\n    });\n  } else {\n    classConstraintFields = classFields;\n  }\n\n  if (allowedSortFields) {\n    classSortFields = allowedSortFields;\n    if (!classSortFields.length) {\n      // must have at least 1 order field\n      // otherwise the FindArgs Input Type will throw.\n      classSortFields.push({\n        field: 'id',\n        asc: true,\n        desc: true,\n      });\n    }\n  } else {\n    classSortFields = classFields.map(field => {\n      return { field, asc: true, desc: true };\n    });\n  }\n\n  return {\n    classCreateFields,\n    classUpdateFields,\n    classConstraintFields,\n    classOutputFields,\n    classSortFields,\n  };\n};\n\nconst load = (parseGraphQLSchema, parseClass, parseClassConfig: ?ParseGraphQLClassConfig) => {\n  const className = parseClass.className;\n  const graphQLClassName = transformClassNameToGraphQL(className);\n  const {\n    classCreateFields,\n    classUpdateFields,\n    classOutputFields,\n    classConstraintFields,\n    classSortFields,\n  } = getInputFieldsAndConstraints(parseClass, parseClassConfig);\n\n  const {\n    create: isCreateEnabled = true,\n    update: isUpdateEnabled = true,\n  } = getParseClassMutationConfig(parseClassConfig);\n\n  const classGraphQLCreateTypeName = `Create${graphQLClassName}FieldsInput`;\n  let classGraphQLCreateType = new GraphQLInputObjectType({\n    name: classGraphQLCreateTypeName,\n    description: `The ${classGraphQLCreateTypeName} input type is used in operations that involve creation of objects in the ${graphQLClassName} class.`,\n    fields: () =>\n      classCreateFields.reduce(\n        (fields, field) => {\n          const type = transformInputTypeToGraphQL(\n            parseClass.fields[field].type,\n            parseClass.fields[field].targetClass,\n            parseGraphQLSchema.parseClassTypes\n          );\n          if (type) {\n            return {\n              ...fields,\n              [field]: {\n                description: `This is the object ${field}.`,\n                type: parseClass.fields[field].required ? new GraphQLNonNull(type) : type,\n              },\n            };\n          } else {\n            return fields;\n          }\n        },\n        {\n          ACL: { type: defaultGraphQLTypes.ACL_INPUT },\n        }\n      ),\n  });\n  classGraphQLCreateType = parseGraphQLSchema.addGraphQLType(classGraphQLCreateType);\n\n  const classGraphQLUpdateTypeName = `Update${graphQLClassName}FieldsInput`;\n  let classGraphQLUpdateType = new GraphQLInputObjectType({\n    name: classGraphQLUpdateTypeName,\n    description: `The ${classGraphQLUpdateTypeName} input type is used in operations that involve creation of objects in the ${graphQLClassName} class.`,\n    fields: () =>\n      classUpdateFields.reduce(\n        (fields, field) => {\n          const type = transformInputTypeToGraphQL(\n            parseClass.fields[field].type,\n            parseClass.fields[field].targetClass,\n            parseGraphQLSchema.parseClassTypes\n          );\n          if (type) {\n            return {\n              ...fields,\n              [field]: {\n                description: `This is the object ${field}.`,\n                type,\n              },\n            };\n          } else {\n            return fields;\n          }\n        },\n        {\n          ACL: { type: defaultGraphQLTypes.ACL_INPUT },\n        }\n      ),\n  });\n  classGraphQLUpdateType = parseGraphQLSchema.addGraphQLType(classGraphQLUpdateType);\n\n  const classGraphQLPointerTypeName = `${graphQLClassName}PointerInput`;\n  let classGraphQLPointerType = new GraphQLInputObjectType({\n    name: classGraphQLPointerTypeName,\n    description: `Allow to link OR add and link an object of the ${graphQLClassName} class.`,\n    fields: () => {\n      const fields = {\n        link: {\n          description: `Link an existing object from ${graphQLClassName} class. You can use either the global or the object id.`,\n          type: GraphQLID,\n        },\n      };\n      if (isCreateEnabled) {\n        fields['createAndLink'] = {\n          description: `Create and link an object from ${graphQLClassName} class.`,\n          type: classGraphQLCreateType,\n        };\n      }\n      return fields;\n    },\n  });\n  classGraphQLPointerType =\n    parseGraphQLSchema.addGraphQLType(classGraphQLPointerType) || defaultGraphQLTypes.OBJECT;\n\n  const classGraphQLRelationTypeName = `${graphQLClassName}RelationInput`;\n  let classGraphQLRelationType = new GraphQLInputObjectType({\n    name: classGraphQLRelationTypeName,\n    description: `Allow to add, remove, createAndAdd objects of the ${graphQLClassName} class into a relation field.`,\n    fields: () => {\n      const fields = {\n        add: {\n          description: `Add existing objects from the ${graphQLClassName} class into the relation. You can use either the global or the object ids.`,\n          type: new GraphQLList(defaultGraphQLTypes.OBJECT_ID),\n        },\n        remove: {\n          description: `Remove existing objects from the ${graphQLClassName} class out of the relation. You can use either the global or the object ids.`,\n          type: new GraphQLList(defaultGraphQLTypes.OBJECT_ID),\n        },\n      };\n      if (isCreateEnabled) {\n        fields['createAndAdd'] = {\n          description: `Create and add objects of the ${graphQLClassName} class into the relation.`,\n          type: new GraphQLList(new GraphQLNonNull(classGraphQLCreateType)),\n        };\n      }\n      return fields;\n    },\n  });\n  classGraphQLRelationType =\n    parseGraphQLSchema.addGraphQLType(classGraphQLRelationType) || defaultGraphQLTypes.OBJECT;\n\n  const classGraphQLConstraintsTypeName = `${graphQLClassName}WhereInput`;\n  let classGraphQLConstraintsType = new GraphQLInputObjectType({\n    name: classGraphQLConstraintsTypeName,\n    description: `The ${classGraphQLConstraintsTypeName} input type is used in operations that involve filtering objects of ${graphQLClassName} class.`,\n    fields: () => ({\n      ...classConstraintFields.reduce((fields, field) => {\n        if (['OR', 'AND', 'NOR'].includes(field)) {\n          parseGraphQLSchema.log.warn(\n            `Field ${field} could not be added to the auto schema ${classGraphQLConstraintsTypeName} because it collided with an existing one.`\n          );\n          return fields;\n        }\n        const parseField = field === 'id' ? 'objectId' : field;\n        const type = transformConstraintTypeToGraphQL(\n          parseClass.fields[parseField].type,\n          parseClass.fields[parseField].targetClass,\n          parseGraphQLSchema.parseClassTypes,\n          field\n        );\n        if (type) {\n          return {\n            ...fields,\n            [field]: {\n              description: `This is the object ${field}.`,\n              type,\n            },\n          };\n        } else {\n          return fields;\n        }\n      }, {}),\n      OR: {\n        description: 'This is the OR operator to compound constraints.',\n        type: new GraphQLList(new GraphQLNonNull(classGraphQLConstraintsType)),\n      },\n      AND: {\n        description: 'This is the AND operator to compound constraints.',\n        type: new GraphQLList(new GraphQLNonNull(classGraphQLConstraintsType)),\n      },\n      NOR: {\n        description: 'This is the NOR operator to compound constraints.',\n        type: new GraphQLList(new GraphQLNonNull(classGraphQLConstraintsType)),\n      },\n    }),\n  });\n  classGraphQLConstraintsType =\n    parseGraphQLSchema.addGraphQLType(classGraphQLConstraintsType) || defaultGraphQLTypes.OBJECT;\n\n  const classGraphQLRelationConstraintsTypeName = `${graphQLClassName}RelationWhereInput`;\n  let classGraphQLRelationConstraintsType = new GraphQLInputObjectType({\n    name: classGraphQLRelationConstraintsTypeName,\n    description: `The ${classGraphQLRelationConstraintsTypeName} input type is used in operations that involve filtering objects of ${graphQLClassName} class.`,\n    fields: () => ({\n      have: {\n        description: 'Run a relational/pointer query where at least one child object can match.',\n        type: classGraphQLConstraintsType,\n      },\n      haveNot: {\n        description:\n          'Run an inverted relational/pointer query where at least one child object can match.',\n        type: classGraphQLConstraintsType,\n      },\n      exists: {\n        description: 'Check if the relation/pointer contains objects.',\n        type: GraphQLBoolean,\n      },\n    }),\n  });\n  classGraphQLRelationConstraintsType =\n    parseGraphQLSchema.addGraphQLType(classGraphQLRelationConstraintsType) ||\n    defaultGraphQLTypes.OBJECT;\n\n  const classGraphQLOrderTypeName = `${graphQLClassName}Order`;\n  let classGraphQLOrderType = new GraphQLEnumType({\n    name: classGraphQLOrderTypeName,\n    description: `The ${classGraphQLOrderTypeName} input type is used when sorting objects of the ${graphQLClassName} class.`,\n    values: classSortFields.reduce((sortFields, fieldConfig) => {\n      const { field, asc, desc } = fieldConfig;\n      const updatedSortFields = {\n        ...sortFields,\n      };\n      const value = field === 'id' ? 'objectId' : field;\n      if (asc) {\n        updatedSortFields[`${field}_ASC`] = { value };\n      }\n      if (desc) {\n        updatedSortFields[`${field}_DESC`] = { value: `-${value}` };\n      }\n      return updatedSortFields;\n    }, {}),\n  });\n  classGraphQLOrderType = parseGraphQLSchema.addGraphQLType(classGraphQLOrderType);\n\n  const classGraphQLFindArgs = {\n    where: {\n      description: 'These are the conditions that the objects need to match in order to be found.',\n      type: classGraphQLConstraintsType,\n    },\n    order: {\n      description: 'The fields to be used when sorting the data fetched.',\n      type: classGraphQLOrderType\n        ? new GraphQLList(new GraphQLNonNull(classGraphQLOrderType))\n        : GraphQLString,\n    },\n    skip: defaultGraphQLTypes.SKIP_ATT,\n    ...connectionArgs,\n    options: defaultGraphQLTypes.READ_OPTIONS_ATT,\n  };\n  const classGraphQLOutputTypeName = `${graphQLClassName}`;\n  const interfaces = [defaultGraphQLTypes.PARSE_OBJECT, parseGraphQLSchema.relayNodeInterface];\n  const parseObjectFields = {\n    id: globalIdField(className, obj => obj.objectId),\n    ...defaultGraphQLTypes.PARSE_OBJECT_FIELDS,\n    ...(className === '_User'\n      ? {\n          authDataResponse: {\n            description: `auth provider response when triggered on signUp/logIn.`,\n            type: defaultGraphQLTypes.OBJECT,\n          },\n        }\n      : {}),\n  };\n  const outputFields = () => {\n    return classOutputFields.reduce((fields, field) => {\n      const type = transformOutputTypeToGraphQL(\n        parseClass.fields[field].type,\n        parseClass.fields[field].targetClass,\n        parseGraphQLSchema.parseClassTypes\n      );\n      if (parseClass.fields[field].type === 'Relation') {\n        const targetParseClassTypes =\n          parseGraphQLSchema.parseClassTypes[parseClass.fields[field].targetClass];\n        const args = targetParseClassTypes ? targetParseClassTypes.classGraphQLFindArgs : undefined;\n        return {\n          ...fields,\n          [field]: {\n            description: `This is the object ${field}.`,\n            args,\n            type: parseClass.fields[field].required ? new GraphQLNonNull(type) : type,\n            async resolve(source, args, context, queryInfo) {\n              try {\n                const { where, order, skip, first, after, last, before, options } = args;\n                const { readPreference, includeReadPreference, subqueryReadPreference } =\n                  options || {};\n                const { config, auth, info } = context;\n                const selectedFields = getFieldNames(queryInfo);\n\n                const { keys, include } = extractKeysAndInclude(\n                  selectedFields\n                    .filter(field => field.startsWith('edges.node.'))\n                    .map(field => field.replace('edges.node.', ''))\n                    .filter(field => field.indexOf('edges.node') < 0)\n                );\n                const parseOrder = order && order.join(',');\n\n                return objectsQueries.findObjects(\n                  source[field].className,\n                  {\n                    $relatedTo: {\n                      object: {\n                        __type: 'Pointer',\n                        className: className,\n                        objectId: source.objectId,\n                      },\n                      key: field,\n                    },\n                    ...(where || {}),\n                  },\n                  parseOrder,\n                  skip,\n                  first,\n                  after,\n                  last,\n                  before,\n                  keys,\n                  include,\n                  false,\n                  readPreference,\n                  includeReadPreference,\n                  subqueryReadPreference,\n                  config,\n                  auth,\n                  info,\n                  selectedFields,\n                  parseGraphQLSchema.parseClasses\n                );\n              } catch (e) {\n                parseGraphQLSchema.handleError(e);\n              }\n            },\n          },\n        };\n      } else if (parseClass.fields[field].type === 'Polygon') {\n        return {\n          ...fields,\n          [field]: {\n            description: `This is the object ${field}.`,\n            type: parseClass.fields[field].required ? new GraphQLNonNull(type) : type,\n            async resolve(source) {\n              if (source[field] && source[field].coordinates) {\n                return source[field].coordinates.map(coordinate => ({\n                  latitude: coordinate[0],\n                  longitude: coordinate[1],\n                }));\n              } else {\n                return null;\n              }\n            },\n          },\n        };\n      } else if (parseClass.fields[field].type === 'Array') {\n        return {\n          ...fields,\n          [field]: {\n            description: `Use Inline Fragment on Array to get results: https://graphql.org/learn/queries/#inline-fragments`,\n            type: parseClass.fields[field].required ? new GraphQLNonNull(type) : type,\n            async resolve(source) {\n              if (!source[field]) { return null; }\n              return source[field].map(async elem => {\n                if (elem.className && elem.objectId && elem.__type === 'Object') {\n                  return elem;\n                } else {\n                  return { value: elem };\n                }\n              });\n            },\n          },\n        };\n      } else if (type) {\n        return {\n          ...fields,\n          [field]: {\n            description: `This is the object ${field}.`,\n            type: parseClass.fields[field].required ? new GraphQLNonNull(type) : type,\n          },\n        };\n      } else {\n        return fields;\n      }\n    }, parseObjectFields);\n  };\n  let classGraphQLOutputType = new GraphQLObjectType({\n    name: classGraphQLOutputTypeName,\n    description: `The ${classGraphQLOutputTypeName} object type is used in operations that involve outputting objects of ${graphQLClassName} class.`,\n    interfaces,\n    fields: outputFields,\n  });\n  classGraphQLOutputType = parseGraphQLSchema.addGraphQLType(classGraphQLOutputType);\n\n  const { connectionType, edgeType } = connectionDefinitions({\n    name: graphQLClassName,\n    connectionFields: {\n      count: defaultGraphQLTypes.COUNT_ATT,\n    },\n    nodeType: classGraphQLOutputType || defaultGraphQLTypes.OBJECT,\n  });\n  let classGraphQLFindResultType = undefined;\n  if (\n    parseGraphQLSchema.addGraphQLType(edgeType) &&\n    parseGraphQLSchema.addGraphQLType(connectionType, false, false, true)\n  ) {\n    classGraphQLFindResultType = connectionType;\n  }\n\n  parseGraphQLSchema.parseClassTypes[className] = {\n    classGraphQLPointerType,\n    classGraphQLRelationType,\n    classGraphQLCreateType,\n    classGraphQLUpdateType,\n    classGraphQLConstraintsType,\n    classGraphQLRelationConstraintsType,\n    classGraphQLFindArgs,\n    classGraphQLOutputType,\n    classGraphQLFindResultType,\n    config: {\n      parseClassConfig,\n      isCreateEnabled,\n      isUpdateEnabled,\n    },\n  };\n\n  if (className === '_User') {\n    const viewerType = new GraphQLObjectType({\n      name: 'Viewer',\n      description: `The Viewer object type is used in operations that involve outputting the current user data.`,\n      fields: () => ({\n        sessionToken: defaultGraphQLTypes.SESSION_TOKEN_ATT,\n        user: {\n          description: 'This is the current user.',\n          type: new GraphQLNonNull(classGraphQLOutputType),\n        },\n      }),\n    });\n    parseGraphQLSchema.addGraphQLType(viewerType, true, true);\n    parseGraphQLSchema.viewerType = viewerType;\n  }\n};\n\nexport { extractKeysAndInclude, load };\n"],"mappings":"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","ignoreList":[]}