parse-server 2.8.4 → 8.6.2

package/lib/GraphQL/loaders/usersMutations.js

@@ -0,0 +1,433 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.load = void 0;
+var _graphql = require("graphql");
+var _graphqlRelay = require("graphql-relay");
+var _deepcopy = _interopRequireDefault(require("deepcopy"));
+var _UsersRouter = _interopRequireDefault(require("../../Routers/UsersRouter"));
+var objectsMutations = _interopRequireWildcard(require("../helpers/objectsMutations"));
+var _defaultGraphQLTypes = require("./defaultGraphQLTypes");
+var _usersQueries = require("./usersQueries");
+var _mutation = require("../transformers/mutation");
+var _node = _interopRequireDefault(require("parse/node"));
+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 usersRouter = new _UsersRouter.default();
+const load = parseGraphQLSchema => {
+  if (parseGraphQLSchema.isUsersClassDisabled) {
+    return;
+  }
+  const signUpMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'SignUp',
+    description: 'The signUp mutation can be used to create and sign up a new user.',
+    inputFields: {
+      fields: {
+        descriptions: 'These are the fields of the new user to be created and signed up.',
+        type: parseGraphQLSchema.parseClassTypes['_User'].classGraphQLCreateType
+      }
+    },
+    outputFields: {
+      viewer: {
+        description: 'This is the new user that was created, signed up and returned as a viewer.',
+        type: new _graphql.GraphQLNonNull(parseGraphQLSchema.viewerType)
+      }
+    },
+    mutateAndGetPayload: async (args, context, mutationInfo) => {
+      try {
+        const {
+          fields
+        } = (0, _deepcopy.default)(args);
+        const {
+          config,
+          auth,
+          info
+        } = context;
+        const parseFields = await (0, _mutation.transformTypes)('create', fields, {
+          className: '_User',
+          parseGraphQLSchema,
+          originalFields: args.fields,
+          req: {
+            config,
+            auth,
+            info
+          }
+        });
+        const {
+          sessionToken,
+          objectId,
+          authDataResponse
+        } = await objectsMutations.createObject('_User', parseFields, config, auth, info);
+        context.info.sessionToken = sessionToken;
+        const viewer = await (0, _usersQueries.getUserFromSessionToken)(context, mutationInfo, 'viewer.user.', objectId);
+        if (authDataResponse && viewer.user) {
+          viewer.user.authDataResponse = authDataResponse;
+        }
+        return {
+          viewer
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(signUpMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(signUpMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('signUp', signUpMutation, true, true);
+  const logInWithMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'LogInWith',
+    description: 'The logInWith mutation can be used to signup, login user with 3rd party authentication system. This mutation create a user if the authData do not correspond to an existing one.',
+    inputFields: {
+      authData: {
+        descriptions: 'This is the auth data of your custom auth provider',
+        type: new _graphql.GraphQLNonNull(_defaultGraphQLTypes.OBJECT)
+      },
+      fields: {
+        descriptions: 'These are the fields of the user to be created/updated and logged in.',
+        type: new _graphql.GraphQLInputObjectType({
+          name: 'UserLoginWithInput',
+          fields: () => {
+            const classGraphQLCreateFields = parseGraphQLSchema.parseClassTypes['_User'].classGraphQLCreateType.getFields();
+            return Object.keys(classGraphQLCreateFields).reduce((fields, fieldName) => {
+              if (fieldName !== 'password' && fieldName !== 'username' && fieldName !== 'authData') {
+                fields[fieldName] = classGraphQLCreateFields[fieldName];
+              }
+              return fields;
+            }, {});
+          }
+        })
+      }
+    },
+    outputFields: {
+      viewer: {
+        description: 'This is the new user that was created, signed up and returned as a viewer.',
+        type: new _graphql.GraphQLNonNull(parseGraphQLSchema.viewerType)
+      }
+    },
+    mutateAndGetPayload: async (args, context, mutationInfo) => {
+      try {
+        const {
+          fields,
+          authData
+        } = (0, _deepcopy.default)(args);
+        const {
+          config,
+          auth,
+          info
+        } = context;
+        const parseFields = await (0, _mutation.transformTypes)('create', fields, {
+          className: '_User',
+          parseGraphQLSchema,
+          originalFields: args.fields,
+          req: {
+            config,
+            auth,
+            info
+          }
+        });
+        const {
+          sessionToken,
+          objectId,
+          authDataResponse
+        } = await objectsMutations.createObject('_User', {
+          ...parseFields,
+          authData
+        }, config, auth, info);
+        context.info.sessionToken = sessionToken;
+        const viewer = await (0, _usersQueries.getUserFromSessionToken)(context, mutationInfo, 'viewer.user.', objectId);
+        if (authDataResponse && viewer.user) {
+          viewer.user.authDataResponse = authDataResponse;
+        }
+        return {
+          viewer
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(logInWithMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(logInWithMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('logInWith', logInWithMutation, true, true);
+  const logInMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'LogIn',
+    description: 'The logIn mutation can be used to log in an existing user.',
+    inputFields: {
+      username: {
+        description: 'This is the username used to log in the user.',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      },
+      password: {
+        description: 'This is the password used to log in the user.',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      },
+      authData: {
+        description: 'Auth data payload, needed if some required auth adapters are configured.',
+        type: _defaultGraphQLTypes.OBJECT
+      }
+    },
+    outputFields: {
+      viewer: {
+        description: 'This is the existing user that was logged in and returned as a viewer.',
+        type: new _graphql.GraphQLNonNull(parseGraphQLSchema.viewerType)
+      }
+    },
+    mutateAndGetPayload: async (args, context, mutationInfo) => {
+      try {
+        const {
+          username,
+          password,
+          authData
+        } = (0, _deepcopy.default)(args);
+        const {
+          config,
+          auth,
+          info
+        } = context;
+        const {
+          sessionToken,
+          objectId,
+          authDataResponse
+        } = (await usersRouter.handleLogIn({
+          body: {
+            username,
+            password,
+            authData
+          },
+          query: {},
+          config,
+          auth,
+          info
+        })).response;
+        context.info.sessionToken = sessionToken;
+        const viewer = await (0, _usersQueries.getUserFromSessionToken)(context, mutationInfo, 'viewer.user.', objectId);
+        if (authDataResponse && viewer.user) {
+          viewer.user.authDataResponse = authDataResponse;
+        }
+        return {
+          viewer
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(logInMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(logInMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('logIn', logInMutation, true, true);
+  const logOutMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'LogOut',
+    description: 'The logOut mutation can be used to log out an existing user.',
+    outputFields: {
+      ok: {
+        description: "It's always true.",
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+      }
+    },
+    mutateAndGetPayload: async (_args, context) => {
+      try {
+        const {
+          config,
+          auth,
+          info
+        } = context;
+        await usersRouter.handleLogOut({
+          config,
+          auth,
+          info
+        });
+        return {
+          ok: true
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(logOutMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(logOutMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('logOut', logOutMutation, true, true);
+  const resetPasswordMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'ResetPassword',
+    description: 'The resetPassword mutation can be used to reset the password of an existing user.',
+    inputFields: {
+      email: {
+        descriptions: 'Email of the user that should receive the reset email',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      }
+    },
+    outputFields: {
+      ok: {
+        description: "It's always true.",
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+      }
+    },
+    mutateAndGetPayload: async ({
+      email
+    }, context) => {
+      const {
+        config,
+        auth,
+        info
+      } = context;
+      await usersRouter.handleResetRequest({
+        body: {
+          email
+        },
+        config,
+        auth,
+        info
+      });
+      return {
+        ok: true
+      };
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(resetPasswordMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(resetPasswordMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('resetPassword', resetPasswordMutation, true, true);
+  const confirmResetPasswordMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'ConfirmResetPassword',
+    description: 'The confirmResetPassword mutation can be used to reset the password of an existing user.',
+    inputFields: {
+      username: {
+        descriptions: 'Username of the user that have received the reset email',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      },
+      password: {
+        descriptions: 'New password of the user',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      },
+      token: {
+        descriptions: 'Reset token that was emailed to the user',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      }
+    },
+    outputFields: {
+      ok: {
+        description: "It's always true.",
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+      }
+    },
+    mutateAndGetPayload: async ({
+      password,
+      token
+    }, context) => {
+      const {
+        config
+      } = context;
+      if (!password) {
+        throw new _node.default.Error(_node.default.Error.PASSWORD_MISSING, 'you must provide a password');
+      }
+      if (!token) {
+        throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'you must provide a token');
+      }
+      const userController = config.userController;
+      await userController.updatePassword(token, password);
+      return {
+        ok: true
+      };
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(confirmResetPasswordMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(confirmResetPasswordMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('confirmResetPassword', confirmResetPasswordMutation, true, true);
+  const sendVerificationEmailMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'SendVerificationEmail',
+    description: 'The sendVerificationEmail mutation can be used to send the verification email again.',
+    inputFields: {
+      email: {
+        descriptions: 'Email of the user that should receive the verification email',
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+      }
+    },
+    outputFields: {
+      ok: {
+        description: "It's always true.",
+        type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+      }
+    },
+    mutateAndGetPayload: async ({
+      email
+    }, context) => {
+      try {
+        const {
+          config,
+          auth,
+          info
+        } = context;
+        await usersRouter.handleVerificationEmailRequest({
+          body: {
+            email
+          },
+          config,
+          auth,
+          info
+        });
+        return {
+          ok: true
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(sendVerificationEmailMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(sendVerificationEmailMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('sendVerificationEmail', sendVerificationEmailMutation, true, true);
+  const challengeMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'Challenge',
+    description: 'The challenge mutation can be used to initiate an authentication challenge when an auth adapter needs it.',
+    inputFields: {
+      username: {
+        description: 'This is the username used to log in the user.',
+        type: _graphql.GraphQLString
+      },
+      password: {
+        description: 'This is the password used to log in the user.',
+        type: _graphql.GraphQLString
+      },
+      authData: {
+        description: 'Auth data allow to preidentify the user if the auth adapter needs preidentification.',
+        type: _defaultGraphQLTypes.OBJECT
+      },
+      challengeData: {
+        description: 'Challenge data payload, can be used to post data to auth providers to auth providers if they need data for the response.',
+        type: _defaultGraphQLTypes.OBJECT
+      }
+    },
+    outputFields: {
+      challengeData: {
+        description: 'Challenge response from configured auth adapters.',
+        type: _defaultGraphQLTypes.OBJECT
+      }
+    },
+    mutateAndGetPayload: async (input, context) => {
+      try {
+        const {
+          config,
+          auth,
+          info
+        } = context;
+        const {
+          response
+        } = await usersRouter.handleChallenge({
+          body: input,
+          config,
+          auth,
+          info
+        });
+        return response;
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(challengeMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(challengeMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('challenge', challengeMutation, true, true);
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_graphql","require","_graphqlRelay","_deepcopy","_interopRequireDefault","_UsersRouter","objectsMutations","_interopRequireWildcard","_defaultGraphQLTypes","_usersQueries","_mutation","_node","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","usersRouter","UsersRouter","load","parseGraphQLSchema","isUsersClassDisabled","signUpMutation","mutationWithClientMutationId","name","description","inputFields","fields","descriptions","type","parseClassTypes","classGraphQLCreateType","outputFields","viewer","GraphQLNonNull","viewerType","mutateAndGetPayload","args","context","mutationInfo","deepcopy","config","auth","info","parseFields","transformTypes","className","originalFields","req","sessionToken","objectId","authDataResponse","createObject","getUserFromSessionToken","user","handleError","addGraphQLType","input","ofType","addGraphQLMutation","logInWithMutation","authData","OBJECT","GraphQLInputObjectType","classGraphQLCreateFields","getFields","keys","reduce","fieldName","logInMutation","username","GraphQLString","password","handleLogIn","body","query","response","logOutMutation","ok","GraphQLBoolean","_args","handleLogOut","resetPasswordMutation","email","handleResetRequest","confirmResetPasswordMutation","token","Parse","Error","PASSWORD_MISSING","OTHER_CAUSE","userController","updatePassword","sendVerificationEmailMutation","handleVerificationEmailRequest","challengeMutation","challengeData","handleChallenge","exports"],"sources":["../../../src/GraphQL/loaders/usersMutations.js"],"sourcesContent":["import { GraphQLNonNull, GraphQLString, GraphQLBoolean, GraphQLInputObjectType } from 'graphql';\nimport { mutationWithClientMutationId } from 'graphql-relay';\nimport deepcopy from 'deepcopy';\nimport UsersRouter from '../../Routers/UsersRouter';\nimport * as objectsMutations from '../helpers/objectsMutations';\nimport { OBJECT } from './defaultGraphQLTypes';\nimport { getUserFromSessionToken } from './usersQueries';\nimport { transformTypes } from '../transformers/mutation';\nimport Parse from 'parse/node';\n\nconst usersRouter = new UsersRouter();\n\nconst load = parseGraphQLSchema => {\n  if (parseGraphQLSchema.isUsersClassDisabled) {\n    return;\n  }\n\n  const signUpMutation = mutationWithClientMutationId({\n    name: 'SignUp',\n    description: 'The signUp mutation can be used to create and sign up a new user.',\n    inputFields: {\n      fields: {\n        descriptions: 'These are the fields of the new user to be created and signed up.',\n        type: parseGraphQLSchema.parseClassTypes['_User'].classGraphQLCreateType,\n      },\n    },\n    outputFields: {\n      viewer: {\n        description: 'This is the new user that was created, signed up and returned as a viewer.',\n        type: new GraphQLNonNull(parseGraphQLSchema.viewerType),\n      },\n    },\n    mutateAndGetPayload: async (args, context, mutationInfo) => {\n      try {\n        const { fields } = deepcopy(args);\n        const { config, auth, info } = context;\n\n        const parseFields = await transformTypes('create', fields, {\n          className: '_User',\n          parseGraphQLSchema,\n          originalFields: args.fields,\n          req: { config, auth, info },\n        });\n\n        const { sessionToken, objectId, authDataResponse } = await objectsMutations.createObject(\n          '_User',\n          parseFields,\n          config,\n          auth,\n          info\n        );\n\n        context.info.sessionToken = sessionToken;\n        const viewer = await getUserFromSessionToken(\n          context,\n          mutationInfo,\n          'viewer.user.',\n          objectId\n        );\n        if (authDataResponse && viewer.user) { viewer.user.authDataResponse = authDataResponse; }\n        return {\n          viewer,\n        };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(signUpMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(signUpMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('signUp', signUpMutation, true, true);\n  const logInWithMutation = mutationWithClientMutationId({\n    name: 'LogInWith',\n    description:\n      'The logInWith mutation can be used to signup, login user with 3rd party authentication system. This mutation create a user if the authData do not correspond to an existing one.',\n    inputFields: {\n      authData: {\n        descriptions: 'This is the auth data of your custom auth provider',\n        type: new GraphQLNonNull(OBJECT),\n      },\n      fields: {\n        descriptions: 'These are the fields of the user to be created/updated and logged in.',\n        type: new GraphQLInputObjectType({\n          name: 'UserLoginWithInput',\n          fields: () => {\n            const classGraphQLCreateFields = parseGraphQLSchema.parseClassTypes[\n              '_User'\n            ].classGraphQLCreateType.getFields();\n            return Object.keys(classGraphQLCreateFields).reduce((fields, fieldName) => {\n              if (\n                fieldName !== 'password' &&\n                fieldName !== 'username' &&\n                fieldName !== 'authData'\n              ) {\n                fields[fieldName] = classGraphQLCreateFields[fieldName];\n              }\n              return fields;\n            }, {});\n          },\n        }),\n      },\n    },\n    outputFields: {\n      viewer: {\n        description: 'This is the new user that was created, signed up and returned as a viewer.',\n        type: new GraphQLNonNull(parseGraphQLSchema.viewerType),\n      },\n    },\n    mutateAndGetPayload: async (args, context, mutationInfo) => {\n      try {\n        const { fields, authData } = deepcopy(args);\n        const { config, auth, info } = context;\n\n        const parseFields = await transformTypes('create', fields, {\n          className: '_User',\n          parseGraphQLSchema,\n          originalFields: args.fields,\n          req: { config, auth, info },\n        });\n\n        const { sessionToken, objectId, authDataResponse } = await objectsMutations.createObject(\n          '_User',\n          { ...parseFields, authData },\n          config,\n          auth,\n          info\n        );\n\n        context.info.sessionToken = sessionToken;\n        const viewer = await getUserFromSessionToken(\n          context,\n          mutationInfo,\n          'viewer.user.',\n          objectId\n        );\n        if (authDataResponse && viewer.user) { viewer.user.authDataResponse = authDataResponse; }\n        return {\n          viewer,\n        };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(logInWithMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(logInWithMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('logInWith', logInWithMutation, true, true);\n\n  const logInMutation = mutationWithClientMutationId({\n    name: 'LogIn',\n    description: 'The logIn mutation can be used to log in an existing user.',\n    inputFields: {\n      username: {\n        description: 'This is the username used to log in the user.',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n      password: {\n        description: 'This is the password used to log in the user.',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n      authData: {\n        description: 'Auth data payload, needed if some required auth adapters are configured.',\n        type: OBJECT,\n      },\n    },\n    outputFields: {\n      viewer: {\n        description: 'This is the existing user that was logged in and returned as a viewer.',\n        type: new GraphQLNonNull(parseGraphQLSchema.viewerType),\n      },\n    },\n    mutateAndGetPayload: async (args, context, mutationInfo) => {\n      try {\n        const { username, password, authData } = deepcopy(args);\n        const { config, auth, info } = context;\n\n        const { sessionToken, objectId, authDataResponse } = (\n          await usersRouter.handleLogIn({\n            body: {\n              username,\n              password,\n              authData,\n            },\n            query: {},\n            config,\n            auth,\n            info,\n          })\n        ).response;\n\n        context.info.sessionToken = sessionToken;\n\n        const viewer = await getUserFromSessionToken(\n          context,\n          mutationInfo,\n          'viewer.user.',\n          objectId\n        );\n        if (authDataResponse && viewer.user) { viewer.user.authDataResponse = authDataResponse; }\n        return {\n          viewer,\n        };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(logInMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(logInMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('logIn', logInMutation, true, true);\n\n  const logOutMutation = mutationWithClientMutationId({\n    name: 'LogOut',\n    description: 'The logOut mutation can be used to log out an existing user.',\n    outputFields: {\n      ok: {\n        description: \"It's always true.\",\n        type: new GraphQLNonNull(GraphQLBoolean),\n      },\n    },\n    mutateAndGetPayload: async (_args, context) => {\n      try {\n        const { config, auth, info } = context;\n\n        await usersRouter.handleLogOut({\n          config,\n          auth,\n          info,\n        });\n\n        return { ok: true };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(logOutMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(logOutMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('logOut', logOutMutation, true, true);\n\n  const resetPasswordMutation = mutationWithClientMutationId({\n    name: 'ResetPassword',\n    description:\n      'The resetPassword mutation can be used to reset the password of an existing user.',\n    inputFields: {\n      email: {\n        descriptions: 'Email of the user that should receive the reset email',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n    },\n    outputFields: {\n      ok: {\n        description: \"It's always true.\",\n        type: new GraphQLNonNull(GraphQLBoolean),\n      },\n    },\n    mutateAndGetPayload: async ({ email }, context) => {\n      const { config, auth, info } = context;\n\n      await usersRouter.handleResetRequest({\n        body: {\n          email,\n        },\n        config,\n        auth,\n        info,\n      });\n\n      return { ok: true };\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(resetPasswordMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(resetPasswordMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('resetPassword', resetPasswordMutation, true, true);\n\n  const confirmResetPasswordMutation = mutationWithClientMutationId({\n    name: 'ConfirmResetPassword',\n    description:\n      'The confirmResetPassword mutation can be used to reset the password of an existing user.',\n    inputFields: {\n      username: {\n        descriptions: 'Username of the user that have received the reset email',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n      password: {\n        descriptions: 'New password of the user',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n      token: {\n        descriptions: 'Reset token that was emailed to the user',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n    },\n    outputFields: {\n      ok: {\n        description: \"It's always true.\",\n        type: new GraphQLNonNull(GraphQLBoolean),\n      },\n    },\n    mutateAndGetPayload: async ({ password, token }, context) => {\n      const { config } = context;\n      if (!password) {\n        throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'you must provide a password');\n      }\n      if (!token) {\n        throw new Parse.Error(Parse.Error.OTHER_CAUSE, 'you must provide a token');\n      }\n\n      const userController = config.userController;\n      await userController.updatePassword(token, password);\n      return { ok: true };\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(\n    confirmResetPasswordMutation.args.input.type.ofType,\n    true,\n    true\n  );\n  parseGraphQLSchema.addGraphQLType(confirmResetPasswordMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation(\n    'confirmResetPassword',\n    confirmResetPasswordMutation,\n    true,\n    true\n  );\n\n  const sendVerificationEmailMutation = mutationWithClientMutationId({\n    name: 'SendVerificationEmail',\n    description:\n      'The sendVerificationEmail mutation can be used to send the verification email again.',\n    inputFields: {\n      email: {\n        descriptions: 'Email of the user that should receive the verification email',\n        type: new GraphQLNonNull(GraphQLString),\n      },\n    },\n    outputFields: {\n      ok: {\n        description: \"It's always true.\",\n        type: new GraphQLNonNull(GraphQLBoolean),\n      },\n    },\n    mutateAndGetPayload: async ({ email }, context) => {\n      try {\n        const { config, auth, info } = context;\n\n        await usersRouter.handleVerificationEmailRequest({\n          body: {\n            email,\n          },\n          config,\n          auth,\n          info,\n        });\n\n        return { ok: true };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(\n    sendVerificationEmailMutation.args.input.type.ofType,\n    true,\n    true\n  );\n  parseGraphQLSchema.addGraphQLType(sendVerificationEmailMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation(\n    'sendVerificationEmail',\n    sendVerificationEmailMutation,\n    true,\n    true\n  );\n\n  const challengeMutation = mutationWithClientMutationId({\n    name: 'Challenge',\n    description:\n      'The challenge mutation can be used to initiate an authentication challenge when an auth adapter needs it.',\n    inputFields: {\n      username: {\n        description: 'This is the username used to log in the user.',\n        type: GraphQLString,\n      },\n      password: {\n        description: 'This is the password used to log in the user.',\n        type: GraphQLString,\n      },\n      authData: {\n        description:\n          'Auth data allow to preidentify the user if the auth adapter needs preidentification.',\n        type: OBJECT,\n      },\n      challengeData: {\n        description:\n          'Challenge data payload, can be used to post data to auth providers to auth providers if they need data for the response.',\n        type: OBJECT,\n      },\n    },\n    outputFields: {\n      challengeData: {\n        description: 'Challenge response from configured auth adapters.',\n        type: OBJECT,\n      },\n    },\n    mutateAndGetPayload: async (input, context) => {\n      try {\n        const { config, auth, info } = context;\n\n        const { response } = await usersRouter.handleChallenge({\n          body: input,\n          config,\n          auth,\n          info,\n        });\n        return response;\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(challengeMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(challengeMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('challenge', challengeMutation, true, true);\n};\n\nexport { load };\n"],"mappings":"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","ignoreList":[]}

package/lib/GraphQL/loaders/usersQueries.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.load = exports.getUserFromSessionToken = void 0;
+var _graphql = require("graphql");
+var _graphqlListFields = _interopRequireDefault(require("graphql-list-fields"));
+var _node = _interopRequireDefault(require("parse/node"));
+var _rest = _interopRequireDefault(require("../../rest"));
+var _parseClassTypes = require("./parseClassTypes");
+var _Auth = require("../../Auth");
+var _Error = require("../../Error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const getUserFromSessionToken = async (context, queryInfo, keysPrefix, userId) => {
+  const {
+    info,
+    config
+  } = context;
+  if (!info || !info.sessionToken) {
+    throw (0, _Error.createSanitizedError)(_node.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token', config);
+  }
+  const sessionToken = info.sessionToken;
+  const selectedFields = (0, _graphqlListFields.default)(queryInfo).filter(field => field.startsWith(keysPrefix)).map(field => field.replace(keysPrefix, ''));
+  const keysAndInclude = (0, _parseClassTypes.extractKeysAndInclude)(selectedFields);
+  const {
+    keys
+  } = keysAndInclude;
+  let {
+    include
+  } = keysAndInclude;
+  if (userId && !keys && !include) {
+    return {
+      sessionToken
+    };
+  } else if (keys && !include) {
+    include = 'user';
+  }
+  if (userId) {
+    // We need to re create the auth context
+    // to avoid security breach if userId is provided
+    context.auth = new _Auth.Auth({
+      config,
+      isMaster: context.auth.isMaster,
+      user: {
+        id: userId
+      }
+    });
+  }
+  const options = {};
+  if (keys) {
+    options.keys = keys.split(',').map(key => `${key}`).join(',');
+  }
+  if (include) {
+    options.include = include.split(',').map(included => `${included}`).join(',');
+  }
+  const response = await _rest.default.find(config, context.auth, '_User',
+  // Get the user it self from auth object
+  {
+    objectId: context.auth.user.id
+  }, options, info.clientVersion, info.context);
+  if (!response.results || response.results.length == 0) {
+    throw (0, _Error.createSanitizedError)(_node.default.Error.INVALID_SESSION_TOKEN, 'Invalid session token', config);
+  } else {
+    const user = response.results[0];
+    return {
+      sessionToken,
+      user
+    };
+  }
+};
+exports.getUserFromSessionToken = getUserFromSessionToken;
+const load = parseGraphQLSchema => {
+  if (parseGraphQLSchema.isUsersClassDisabled) {
+    return;
+  }
+  parseGraphQLSchema.addGraphQLQuery('viewer', {
+    description: 'The viewer query can be used to return the current user data.',
+    type: new _graphql.GraphQLNonNull(parseGraphQLSchema.viewerType),
+    async resolve(_source, _args, context, queryInfo) {
+      try {
+        return await getUserFromSessionToken(context, queryInfo, 'user.', false);
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  }, true, true);
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_graphql","require","_graphqlListFields","_interopRequireDefault","_node","_rest","_parseClassTypes","_Auth","_Error","e","__esModule","default","getUserFromSessionToken","context","queryInfo","keysPrefix","userId","info","config","sessionToken","createSanitizedError","Parse","Error","INVALID_SESSION_TOKEN","selectedFields","getFieldNames","filter","field","startsWith","map","replace","keysAndInclude","extractKeysAndInclude","keys","include","auth","Auth","isMaster","user","id","options","split","key","join","included","response","rest","find","objectId","clientVersion","results","length","exports","load","parseGraphQLSchema","isUsersClassDisabled","addGraphQLQuery","description","type","GraphQLNonNull","viewerType","resolve","_source","_args","handleError"],"sources":["../../../src/GraphQL/loaders/usersQueries.js"],"sourcesContent":["import { GraphQLNonNull } from 'graphql';\nimport getFieldNames from 'graphql-list-fields';\nimport Parse from 'parse/node';\nimport rest from '../../rest';\nimport { extractKeysAndInclude } from './parseClassTypes';\nimport { Auth } from '../../Auth';\nimport { createSanitizedError } from '../../Error';\n\nconst getUserFromSessionToken = async (context, queryInfo, keysPrefix, userId) => {\n  const { info, config } = context;\n  if (!info || !info.sessionToken) {\n    throw  createSanitizedError(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token', config);\n  }\n  const sessionToken = info.sessionToken;\n  const selectedFields = getFieldNames(queryInfo)\n    .filter(field => field.startsWith(keysPrefix))\n    .map(field => field.replace(keysPrefix, ''));\n\n  const keysAndInclude = extractKeysAndInclude(selectedFields);\n  const { keys } = keysAndInclude;\n  let { include } = keysAndInclude;\n\n  if (userId && !keys && !include) {\n    return {\n      sessionToken,\n    };\n  } else if (keys && !include) {\n    include = 'user';\n  }\n\n  if (userId) {\n    // We need to re create the auth context\n    // to avoid security breach if userId is provided\n    context.auth = new Auth({\n      config,\n      isMaster: context.auth.isMaster,\n      user: { id: userId },\n    });\n  }\n\n  const options = {};\n  if (keys) {\n    options.keys = keys\n      .split(',')\n      .map(key => `${key}`)\n      .join(',');\n  }\n  if (include) {\n    options.include = include\n      .split(',')\n      .map(included => `${included}`)\n      .join(',');\n  }\n\n  const response = await rest.find(\n    config,\n    context.auth,\n    '_User',\n    // Get the user it self from auth object\n    { objectId: context.auth.user.id },\n    options,\n    info.clientVersion,\n    info.context\n  );\n  if (!response.results || response.results.length == 0) {\n    throw createSanitizedError(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token', config);\n  } else {\n    const user = response.results[0];\n    return {\n      sessionToken,\n      user,\n    };\n  }\n};\n\nconst load = parseGraphQLSchema => {\n  if (parseGraphQLSchema.isUsersClassDisabled) {\n    return;\n  }\n\n  parseGraphQLSchema.addGraphQLQuery(\n    'viewer',\n    {\n      description: 'The viewer query can be used to return the current user data.',\n      type: new GraphQLNonNull(parseGraphQLSchema.viewerType),\n      async resolve(_source, _args, context, queryInfo) {\n        try {\n          return await getUserFromSessionToken(context, queryInfo, 'user.', false);\n        } catch (e) {\n          parseGraphQLSchema.handleError(e);\n        }\n      },\n    },\n    true,\n    true\n  );\n};\n\nexport { load, getUserFromSessionToken };\n"],"mappings":"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","ignoreList":[]}