graphql_devise 0.12.1 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f2bd00ac9c5edc119bb83326ffa996ab57a5551474887281857ef10ee7abb9
-  data.tar.gz: a8e1b662d697f4e8f94faf41b3ccbfec9b4ae6eb295ee4ee004c80d0c2b723bb
+  metadata.gz: f3d25f0672c378bfd003351aa997e61fdfce123ed3b391ed5bddce60c86c4f28
+  data.tar.gz: 0052cc77751cf44d704cfc8c7f462c5ee1aed58c91ad7ba1e80068b085149f88
 SHA512:
-  metadata.gz: c6be77b7524f9a3cbf17b047fc5fbedc5d2cc0158ee343bdb470fe468774d3c3c7b1b0e80f2d529d623e3e74f32bf6d61f1dd220ebc2e66d7863346cedafde25
-  data.tar.gz: c6264ad438bfbec20b53c77bf9997e0a2a6d4ef184488f0a4830e5cad7c7f8f01112e163ec1fb0b5ed86718e488899373706245f22fc6c754280c74daec8a510
+  metadata.gz: 3ee604289ff30fe95a1947ee63a58c05b2a05a659657253e29ed526213bea1558d6162597daf08be56a131a0c3c3100dc2affe1b821674f493d03939ad1540ee
+  data.tar.gz: cd6b4af9fda08c2310e6a47d3d9db8b451031bbbf05b0f214ca71a230d248d64c65cc18a92711b46676d20f047f669d5cdcb1fe6df3a42748109ff3bfae7d709

data/.travis.yml

@@ -24,6 +24,7 @@ gemfile:
   - gemfiles/rails5.2_graphql1.8.gemfile
   - gemfiles/rails5.2_graphql1.9.gemfile
   - gemfiles/rails5.2_graphql1.10.gemfile
+  - gemfiles/rails5.2_graphql1.11.gemfile
 
 jobs:
   include:
@@ -45,6 +46,12 @@ jobs:
       rvm: 2.6.6
     - gemfile: gemfiles/rails6.0_graphql1.10.gemfile
       rvm: 2.7.1
+    - gemfile: gemfiles/rails6.0_graphql1.11.gemfile
+      rvm: 2.5.8
+    - gemfile: gemfiles/rails6.0_graphql1.11.gemfile
+      rvm: 2.6.6
+    - gemfile: gemfiles/rails6.0_graphql1.11.gemfile
+      rvm: 2.7.1
     - gemfile: gemfiles/rails6.0_graphql_edge.gemfile
       rvm: 2.6.6
       env:

data/Appraisals

@@ -61,6 +61,13 @@ appraise 'rails5.2-graphql1.10' do
   gem 'rspec-rails', '< 4.0'
 end
 
+appraise 'rails5.2-graphql1.11' do
+  gem 'sqlite3', '~> 1.3.6'
+  gem 'rails', github: 'rails/rails', branch: '5-2-stable'
+  gem 'graphql', '~> 1.11.0'
+  gem 'rspec-rails', '< 4.0'
+end
+
 appraise 'rails6.0-graphql1.8' do
   gem 'sqlite3', '~> 1.4'
   gem 'devise', '>= 4.7'
@@ -82,6 +89,13 @@ appraise 'rails6.0-graphql1.10' do
   gem 'graphql', '~> 1.10.0'
 end
 
+appraise 'rails6.0-graphql1.11' do
+  gem 'sqlite3', '~> 1.4'
+  gem 'devise', '>= 4.7'
+  gem 'rails', github: 'rails/rails', branch: '6-0-stable'
+  gem 'graphql', '~> 1.11.0'
+end
+
 appraise 'rails6.0-graphql_edge' do
   gem 'sqlite3', '~> 1.4'
   gem 'devise_token_auth', github: 'lynndylanhurley/devise_token_auth', branch: 'master'

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## [v0.13.2](https://github.com/graphql-devise/graphql_devise/tree/v0.13.2) (2020-08-12)
+
+[Full Changelog](https://github.com/graphql-devise/graphql_devise/compare/v0.13.1...v0.13.2)
+
+**Fixed bugs:**
+
+- Save resource after generating credentials in resource confirmation [\#125](https://github.com/graphql-devise/graphql_devise/pull/125) ([mcelicalderon](https://github.com/mcelicalderon))
+
+## [v0.13.1](https://github.com/graphql-devise/graphql_devise/tree/v0.13.1) (2020-07-29)
+
+[Full Changelog](https://github.com/graphql-devise/graphql_devise/compare/v0.13.0...v0.13.1)
+
+**Implemented enhancements:**
+
+- Add credentials field on signUp mutation [\#122](https://github.com/graphql-devise/graphql_devise/pull/122) ([mcelicalderon](https://github.com/mcelicalderon))
+
+**Closed issues:**
+
+- Checking for `performed?` when mounting into your graphql schema. [\#110](https://github.com/graphql-devise/graphql_devise/issues/110)
+- no query string for email reset [\#104](https://github.com/graphql-devise/graphql_devise/issues/104)
+
+## [v0.13.0](https://github.com/graphql-devise/graphql_devise/tree/v0.13.0) (2020-06-22)
+
+[Full Changelog](https://github.com/graphql-devise/graphql_devise/compare/v0.12.3...v0.13.0)
+
+**Breaking changes:**
+
+- Fix email reconfirmation feature [\#111](https://github.com/graphql-devise/graphql_devise/pull/111) ([mcelicalderon](https://github.com/mcelicalderon))
+
+**Implemented enhancements:**
+
+- Add frozen string literal to all relevant files [\#114](https://github.com/graphql-devise/graphql_devise/pull/114) ([mcelicalderon](https://github.com/mcelicalderon))
+
+**Fixed bugs:**
+
+- CookieOverflow for Own Schema Mount [\#112](https://github.com/graphql-devise/graphql_devise/issues/112)
+- Reconfirmable not setting unconfirmed\_email [\#102](https://github.com/graphql-devise/graphql_devise/issues/102)
+
+## [v0.12.3](https://github.com/graphql-devise/graphql_devise/tree/v0.12.3) (2020-06-19)
+
+[Full Changelog](https://github.com/graphql-devise/graphql_devise/compare/v0.12.2...v0.12.3)
+
+**Implemented enhancements:**
+
+- Add support for graphql 1.11 [\#108](https://github.com/graphql-devise/graphql_devise/pull/108) ([mcelicalderon](https://github.com/mcelicalderon))
+
+## [v0.12.2](https://github.com/graphql-devise/graphql_devise/tree/v0.12.2) (2020-06-17)
+
+[Full Changelog](https://github.com/graphql-devise/graphql_devise/compare/v0.12.1...v0.12.2)
+
+**Breaking changes:**
+
+- Fix set\_resource\_by\_token no mapping error in no eager load envs [\#107](https://github.com/graphql-devise/graphql_devise/pull/107) ([mcelicalderon](https://github.com/mcelicalderon))
+
+**Fixed bugs:**
+
+- Separate endpoint url for mailers even if mounting the gem in your own schema [\#105](https://github.com/graphql-devise/graphql_devise/issues/105)
+- Devise mapping error [\#103](https://github.com/graphql-devise/graphql_devise/issues/103)
+- Use the url where the schema is mounted in emails links [\#106](https://github.com/graphql-devise/graphql_devise/pull/106) ([00dav00](https://github.com/00dav00))
+
 ## [v0.12.1](https://github.com/graphql-devise/graphql_devise/tree/v0.12.1) (2020-06-12)
 
 [Full Changelog](https://github.com/graphql-devise/graphql_devise/compare/v0.12.0...v0.12.1)

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -14,19 +14,22 @@ GraphQL interface on top of the [Devise Token Auth](https://github.com/lynndylan
       * [Installation](#installation)
          * [Running the Generator](#running-the-generator)
             * [Mounting the Schema in a Separate Route](#mounting-the-schema-in-a-separate-route)
-            * [Mounting Operations in Your Own Schema](#mounting-operations-in-your-own-schema)
-         * [Important](#important)
+               * [Important](#important)
+            * [Mounting Operations in Your Own Schema (> v0.12.0)](#mounting-operations-in-your-own-schema--v0120)
+               * [Important](#important-1)
       * [Usage](#usage)
          * [Mounting Auth Schema on a Separate Route](#mounting-auth-schema-on-a-separate-route)
          * [Mounting Operations Into Your Own Schema](#mounting-operations-into-your-own-schema)
          * [Available Mount Options](#available-mount-options)
          * [Available Operations](#available-operations)
          * [Configuring Model](#configuring-model)
+         * [Email Reconfirmation](#email-reconfirmation)
          * [Customizing Email Templates](#customizing-email-templates)
          * [I18n](#i18n)
          * [Authenticating Controller Actions](#authenticating-controller-actions)
             * [Authenticate Before Reaching Your GQL Schema](#authenticate-before-reaching-your-gql-schema)
             * [Authenticate in Your GQL Schema](#authenticate-in-your-gql-schema)
+            * [Important](#important-2)
          * [Making Requests](#making-requests)
             * [Mutations](#mutations)
             * [Queries](#queries)
@@ -39,20 +42,19 @@ GraphQL interface on top of the [Devise Token Auth](https://github.com/lynndylan
       * [Contributing](#contributing)
       * [License](#license)
 
-<!-- Added by: mcelicalderon, at: Wed Jun 10 22:10:26 -05 2020 -->
+<!-- Added by: david, at: mar jul 14 08:08:02 -05 2020 -->
 
 <!--te-->
 
 ## Introduction
-This gem heavily relies on two gems, [Devise Token Auth](https://github.com/lynndylanhurley/devise_token_auth) (DTA)
-and [Devise](https://github.com/heartcombo/devise) which is a dependency of DTA.
-It provides a GraphQL interface on top of DTA which is designed to work with REST APIs. That's why
-things like token management, token expiration and everything up until using the actual GraphQL schema is
-still controlled by DTA. For that reason you will find that our generator runs these two gems generator and two
-initializer files are included. We'll provide more configuration details in the
-[configuration section](#more-configuration-options),
-but **we recommend you get familiar with [DTA and their docs](https://github.com/lynndylanhurley/devise_token_auth)
-in order to use this gem to its full potential**.
+Graphql-Devise heavily relies on two gems:
+- [Devise Token Auth](https://github.com/lynndylanhurley/devise_token_auth) (DTA)
+- [Devise](https://github.com/heartcombo/devise) (which is a DTA dependency)
+
+This gem provides a GraphQL interface on top of DTA which is designed for REST APIs. Features like token management, token expiration and everything up until using the actual GraphQL schema is still controlled by DTA. For that reason the gem's generator invokes DTA and Devise generators and creates initializer files for each one of them.
+
+**We strongly recommend getting familiar with [DTA documentation](https://github.com/lynndylanhurley/devise_token_auth) to use this gem to its full potential**.
+More configuration details available in [configuration section](#more-configuration-options)
 
 ## Installation
 
@@ -68,20 +70,21 @@ $ bundle
 ```
 
 ### Running the Generator
-Graphql Devise generator will execute `Devise` and `Devise Token Auth`
-generators for you. These will make the required changes for the gems to
-work correctly. All configurations for [Devise](https://github.com/plataformatec/devise) and
-[Devise Token Auth](https://github.com/lynndylanhurley/devise_token_auth) are available,
-so you can read the docs there to customize your options.
-Configurations are done via initializer files as usual, one per gem.
+Graphql Devise generator will execute `Devise` and `Devise Token Auth` generators to setup the gems in your project. You can customize them to your needs using their initializer files(one per gem) as usual.
 
-#### Mounting the Schema in a Separate Route
 ```bash
 $ bundle exec rails generate graphql_devise:install
 ```
+The generator accepts 2 params:
+- `user_class`: Model name in which `Devise` modules will be included. This uses a `find or create` strategy. Defaults to `User`.
+- `mount_path`: Path in which the dedicated graphql schema for devise will be mounted. Defaults to `/graphql_auth`.
 
-The generator accepts 2 params: `user_class` and `mount_path`. The params
-will be used to mount the route in `config/routes.rb`. For instance the executing:
+The option `mount` is available starting from `v0.12.0`. This option will allow you to mount the operations in your own schema instead of a dedicated one. When this option is provided `mount_path` param is not used.
+
+#### Mounting the Schema in a Separate Route
+
+To configure the gem to use a separate schema, the generator will use `user_class` and `mount_path` params.
+The route will be mounted in `config/routes.rb`. For instance the executing:
 
 ```bash
 $ bundle exec rails g graphql_devise:install Admin api/auth
@@ -99,32 +102,43 @@ Will do the following:
 `Admin` could be any model name you are going to be using for authentication,
 and `api/auth` could be any mount path you would like to use for auth.
 
-#### Mounting Operations in Your Own Schema
-Now you can provide to the generator an option specifying
-the name of your GQL schema. Doing this will skip the insertion of the mount method in the
-routes file and will also add our `SchemaPlugin` to the specified schema. `user_class` param is still optional (`Admin`) in the following example.
+##### Important
+ - Remember that by default this gem mounts a completely separate GraphQL schema on a separate controller in the route provided by the `at` option in the `mount_graphql_devise_for` method in the `config/routes.rb` file. If no `at` option is provided, the route will be `/graphql_auth`.
+ - Avoid passing the `--mount` option or the gem will try to use an existing schema.
+
+#### Mounting Operations in Your Own Schema (> v0.12.0)
+To configure the gem to use your own GQL schema use the `--mount` option. 
+For instance the executing:
 
 ```bash
 $ bundle exec rails g graphql_devise:install Admin --mount MySchema
 ```
 
-### Important
-Remember that by default this gem mounts a completely separate GraphQL schema on a separate controller in the route
-provided by the `at` option in the `mount_graphql_devise_for` method in the `config/routes.rb` file. If no `at`
-option is provided, the route will be `/graphql_auth`.
+Will do the following:
+- Execute `Devise` install generator
+- Execute `Devise Token Auth` install generator with `Admin` and `api/auth` as params
+  - Find or create `Admin` model
+  - Add `devise` modules to `Admin` model
+  - Other changes that you can find [here](https://devise-token-auth.gitbook.io/devise-token-auth/config)
+  - Add `SchemaPlugin` to the specified schema.
+
 
-**Starting with `v0.12.0`** you can opt-in to load this gem's queries and mutations into your
-own application's schema. You can actually mount a resource's auth schema in a separate route
-and in your app's schema at the same time, but that's probably not a common scenario. More on
-this in the next section.
+##### Important
+ - When using the `--mount` option the `mount_path` params is ignored.
+ - The generator will look for your schema under `app/graphql/` directory. We are expecting the name of the file is the same as the as the one passed in the mount option transformed with `underscore`. In the example, passing `MySchema`, will try to find the file `app/graphql/my_schema.rb`.
+ - You can actually mount a resource's auth schema in a separate route and in your app's schema at the same time, but that's probably not a common scenario.
 
 ## Usage
-### Mounting Auth Schema on a Separate Route
-The generator can do this step for you by default. Remember now you can mount this gem's
-auth operations into your own schema as described in [this section](#mounting-operations-into-your-own-schema).
 
+GraphqlDevise operations can be used in two ways:
+- Using a [separate schema](#mounting-auth-schema-on-a-separate-route) via `mount_graphql_devise_for` helper in the routes file.
+- Using [your own schema](#mounting-operations-into-your-own-schema) by adding a plugin in the class.
+
+
+Creating a separate schema is the default option, the generator will do that by default.
+
+### Mounting Auth Schema on a Separate Route
 
-Routes can be added using the generator or manually.
 You can mount this gem's GraphQL auth schema in your routes file like this:
 
 ```ruby
@@ -150,11 +164,13 @@ Rails.application.routes.draw do
   )
 end
 ```
+This can be done using the generator or manually.
 The second argument of the `mount_graphql_devise` method is a hash of options where you can
 customize how the queries and mutations are mounted into the schema. For a list of available
 options go [here](#available-mount-options)
 
 ### Mounting Operations Into Your Own Schema
+
 Starting with `v0.12.0` you can now mount the GQL operations provided by this gem into your
 app's main schema.
 
@@ -301,6 +317,44 @@ end
 The install generator can do this for you if you specify the `user_class` option.
 See [Installation](#installation) for details.
 
+### Email Reconfirmation
+DTA and Devise support email reconfirmation. When the `confirmable` module is added to your
+resource, an email is sent to the provided email address when the `signUp` mutation is used.
+You can also use this gem so every time a user updates the `email` field, a new email gets sent
+for the user to confirm the new email address. Only after clicking on the confirmation link,
+the email will be updated on the database to use the new value.
+
+In order to use this feature there are a couple of things to setup first:
+1. Make user your model includes the `:confirmable` module.
+1. Add an `unconfirmed_email` String column to your resource's table.
+
+After that is done, you simply need to call a different update method on your resource,
+`update_with_email`. This method behaves exactly the same as ActiveRecord's `update` method
+if the previous steps are not performed, or if you are not updating the `email` attribute.
+It is also mandatory to provide two additional attributes when email will change or an error
+will be raised:
+
+1. `schema_url`: The full url where your GQL schema is mounted. You can get this value from the
+controller available in the context of your mutations and queries like this:
+```ruby
+  context[:controller].full_url_without_params
+```
+1. `confirmation_success_url`: This the full url where you want users to be redirected after
+the email has changed successfully (usually a front-end url). This value is mandatory
+unless you have set `default_confirm_success_url` in your devise_token_auth initializer.
+
+So, it's up to you where you require confirmation of changing emails.
+[Here's an example](https://github.com/graphql-devise/graphql_devise/blob/c4dcb17e98f8d84cc5ac002c66ed98a797d3bc82/spec/dummy/app/graphql/mutations/update_user.rb#L13)
+on how you might do this. And also a demonstration on the method usage:
+```ruby
+user.update_with_email(
+  name:                     'New Name',
+  email:                    'new@domain.com',
+  schema_url:               'http://localhost:3000/graphql',
+  confirmation_success_url: 'https://google.com'
+)
+```
+
 ### Customizing Email Templates
 The approach of this gem is a bit different from DeviseTokenAuth. We have placed our templates in `app/views/graphql_devise/mailer`,
 so if you want to change them, place yours on the same dir structure on your Rails project. You can customize these two templates:
@@ -316,11 +370,10 @@ GraphQL Devise supports locales. For example, the `graphql_devise.confirmations.
 Keep in mind that if your app uses multiple locales, you should set the `I18n.locale` accordingly. You can learn how to do this [here](https://guides.rubyonrails.org/i18n.html).
 
 ### Authenticating Controller Actions
-Just like with Devise or DTA, you will need to authenticate users in your controllers.
-For this you have two alternatives.
+When mounting the operation is in you own schema instead of a dedicated one, you will need to authenticate users in your controllers, just like in DTA. There are 2 alternatives to accomplish this.
 
 #### Authenticate Before Reaching Your GQL Schema
-For this you need to call `authenticate_<model>!` in a before_action hook of your controller.
+For this you will need to call `authenticate_<model>!` in a `before_action` controller hook.
 In our example our model is `User`, so it would look like this:
 ```ruby
 # app/controllers/my_controller.rb
@@ -331,20 +384,18 @@ class MyController < ApplicationController
   before_action :authenticate_user!
 
   def my_action
-    render json: { current_user: current_user }
+    result = DummySchema.execute(params[:query], context: current_user: current_user)
+    render json: result unless performed?
   end
 end
 ```
 
-The install generator can do this for you because it executes DTA installer.
-See [Installation](#Installation) for details.
-If authentication fails for the request for whatever reason, execution of the request is halted
-and an error is returned in a REST format as the request never reaches your GQL schema.
+The install generator can include the concern in you application controller.
+If authentication fails for a request, execution will halt and a REST error will be returned since the request never reaches your GQL schema.
 
 #### Authenticate in Your GQL Schema
 For this you will need to add the `GraphqlDevise::SchemaPlugin` to your schema as described
-[here](#mounting-operations-into-your-own-schema) and also set the authenticated resource
-in a `before_action` hook.
+[here](#mounting-operations-into-your-own-schema).
 
 ```ruby
 # app/controllers/my_controller.rb
@@ -352,29 +403,25 @@ in a `before_action` hook.
 class MyController < ApplicationController
   include GraphqlDevise::Concerns::SetUserByToken
 
-  before_action -> { set_resource_by_token(:user) }
-
   def my_action
-    render json: DummySchema.execute(params[:query], context: graphql_context)
+    result = DummySchema.execute(params[:query], context: graphql_context(:user))
+    render json: result unless performed?
   end
 end
-
-# @resource.to_s.underscore.tr('/', '_').to_sym
 ```
-The `set_resource_by_token` method receives a symbol identifying the resource you are trying
+The `graphql_context` method receives a symbol identifying the resource you are trying
 to authenticate. So if you mounted the `'User'` resource, the symbol is `:user`. You can use
 this snippet to find the symbol for more complex scenarios
-`resource_klass.to_s.underscore.tr('/', '_').to_sym`.
+`resource_klass.to_s.underscore.tr('/', '_').to_sym`. `graphql_context` can also take an
+array of resources if you mounted more than one into your schema. The gem will try to
+authenticate a resource for each element on the array until it finds one.
 
-The `graphql_context` method is simply a helper method that returns a hash like this
-```ruby
-{ current_resource: @resource, controller: self }
-```
-These are the two values the gem needs to check if a user is authenticated and to perform
-other auth operations. All `set_resource_by_token` does is set the `@resource` variable if
-the provided authentication headers are valid. If authentication fails, resource will be `nil`
-and this is how `GraphqlDevise::SchemaPlugin` knows if a user is authenticated or not in
-each query.
+Internally in your own mutations and queries a key `current_resource` will be available in
+the context if a resource was successfully authenticated or `nil` otherwise.
+
+Keep in mind that sending multiple values to the `graphql_context` method means that depending
+on who makes the request, the context value `current_resource` might contain instances of the
+different models you might have mounted into the schema.
 
 Please note that by using this mechanism your GQL schema will be in control of what queries are
 restricted to authenticated users and you can only do this at the root level fields of your GQL
@@ -395,32 +442,28 @@ module Types
 end
 ```
 
+#### Important
+Remember to check `performed?` before rendering the result of the graphql operation. This is required because some operations perform a redirect and without this check you will get a `AbstractController::DoubleRenderError`.
+
 ### Making Requests
 Here is a list of the available mutations and queries assuming your mounted model is `User`.
 
 #### Mutations
-1. `userLogin(email: String!, password: String!): UserLoginPayload`
-
-    This mutation has a second field by default. `credentials` can be fetched directly on the mutation return type.
-    Credentials are still returned in the headers of the response.
-
-1. `userLogout: UserLogoutPayload`
-1. `userSignUp(email: String!, password: String!, passwordConfirmation: String!, confirmSuccessUrl: String): UserSignUpPayload`
-
-   The parameter `confirmSuccessUrl` is optional unless you are using the `confirmable` plugin from Devise in your `resource`'s model. If you have `confirmable` set up, you will have to provide it unless you have `config.default_confirm_success_url` set in `config/initializers/devise_token_auth.rb`.
-1. `userSendResetPassword(email: String!, redirectUrl: String!): UserSendReserPasswordPayload`
-1. `userUpdatePassword(password: String!, passwordConfirmation: String!, currentPassword: String): UserUpdatePasswordPayload`
-
-    The parameter `currentPassword` is optional if you have `config.check_current_password_before_update` set to
-    false (disabled by default) on your generated `config/initializers/devise_token_aut.rb` or if the `resource`
-    model supports the `recoverable` Devise plugin and the `resource`'s `allow_password_change` attribute is set to true (this is done in the `userCheckPasswordToken` query when you click on the sent email's link).
-1. `userResendConfirmation(email: String!, redirectUrl: String!): UserResendConfirmationPayload`
 
-    The `UserResendConfirmationPayload` will return the `authenticatable` resource that was sent the confirmation instructions but also has a `message: String!` that can be used to notify a user what to do after the instructions were sent to them
+Operation | Description | Example
+:--- | :--- | :------------------:
+login | This mutation has a second field by default. `credentials` can be fetched directly on the mutation return type.<br>Credentials are still returned in the headers of the response. | userLogin(email: String!, password: String!): UserLoginPayload
+logout | | userLogout: UserLogoutPayload
+signUp | The parameter `confirmSuccessUrl` is optional unless you are using the `confirmable` plugin from Devise in your `resource`'s model. If you have `confirmable` set up, you will have to provide it unless you have `config.default_confirm_success_url` set in `config/initializers/devise_token_auth.rb`. | userSignUp(email: String!, password: String!, passwordConfirmation: String!, confirmSuccessUrl: String): UserSignUpPayload
+sendResetPassword | | userSendResetPassword(email: String!, redirectUrl: String!): UserSendReserPasswordPayload
+updatePassword | The parameter `currentPassword` is optional if you have `config.check_current_password_before_update` set to false (disabled by default) on your generated `config/initializers/devise_token_aut.rb` or if the `resource` model supports the `recoverable` Devise plugin and the `resource`'s `allow_password_change` attribute is set to true (this is done in the `userCheckPasswordToken` query when you click on the sent email's link). | userUpdatePassword(password: String!, passwordConfirmation: String!, currentPassword: String): UserUpdatePasswordPayload
+resendConfirmation | The `UserResendConfirmationPayload` will return the `authenticatable` resource that was sent the confirmation instructions but also has a `message: String!` that can be used to notify a user what to do after the instructions were sent to them | userResendConfirmation(email: String!, redirectUrl: String!): UserResendConfirmationPayload
 
 #### Queries
-1. `userConfirmAccount(confirmationToken: String!, redirectUrl: String!): User`
-1. `userCheckPasswordToken(resetPasswordToken: String!, redirectUrl: String): User`
+Operation | Description | Example
+:--- | :--- | :------------------:
+confirmAccount | Performs a redirect using the `redirectUrl` param | userConfirmAccount(confirmationToken: String!, redirectUrl: String!): User
+checkPasswordToken | Performs a redirect using the `redirectUrl` param | userCheckPasswordToken(resetPasswordToken: String!, redirectUrl: String): User
 
 The reason for having 2 queries is that these 2 are going to be accessed when clicking on
 the confirmation and reset password email urls. There is no limitation for making mutation