devise_token_auth 0.1.43 → 1.2.0

data/lib/devise_token_auth/token_factory.rb

@@ -0,0 +1,126 @@
+require 'bcrypt'
+
+module DeviseTokenAuth
+  # A token management factory which allow generate token objects and check them.
+  module TokenFactory
+    # For BCrypt::Password class see:
+    # https://github.com/codahale/bcrypt-ruby/blob/master/lib/bcrypt/password.rb
+
+    # Creates a token instance. Takes an optional client, lifespan and cost options.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.create
+    #   => #<struct DeviseTokenAuth::TokenFactory::Token client="tElcgkdZ7f9XEa0unZhrYQ", token="rAMcWOs0-mGHFMnIgJD2cA", token_hash="$2a$10$wrsdlHVRGlYW11wfImxU..jr0Ux3bHo/qbXcSfgp8zmvVUNHosita", expiry=1518982690>
+    #
+    #   DeviseTokenAuth::TokenFactory.create(lifespan: 10, cost: 4)
+    #   => #<struct DeviseTokenAuth::TokenFactory::Token client="5qleT7_t9JPVcX9xmxkVYA", token="RBXX43u4xXNSO-fr2N_4pA", token_hash="$2a$04$9gpCaoFbu2dUKxU3qiTgluHX7jj9UzS.jq1QW0EkQmoaxARo1WxTy", expiry=1517773268>
+    def self.create(client: nil, lifespan: nil, cost: nil)
+      # obj_client  = client.nil? ? client() : client
+      obj_client  = client || client()
+      obj_token      = token
+      obj_token_hash = token_hash(obj_token, cost)
+      obj_expiry     = expiry(lifespan)
+
+      Token.new(obj_client, obj_token, obj_token_hash, obj_expiry)
+    end
+
+    # Generates a random URL-safe client.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.client
+    #   => "zNf0pNP5iGfuBItZJGCseQ"
+    def self.client
+      secure_string
+    end
+
+    # Generates a random URL-safe token.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.token
+    #   => "6Bqs4K9x8ChLmZogvruF3A"
+    def self.token
+      secure_string
+    end
+
+    # Returns token hash for a token with given cost. If no cost value is specified,
+    # the default value is used. The possible cost value is within range from 4 to 31.
+    # It is recommended to not use a value more than 10.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.token_hash("_qxAxmc-biQLiYRHsmwd5Q")
+    #   => "$2a$10$6/cTAtQ3CBLfpkeHW7dlt.PD2aVCbFRN5vDDJUUhGsZ6pzYFlh4Me"
+    #
+    #   DeviseTokenAuth::TokenFactory.token_hash("_qxAxmc-biQLiYRHsmwd5Q", 4)
+    #   => "$2a$04$RkIrosbdRtuet2eUk3si8eS4ufeNpiPc/rSSsfpniRK8ogM5YFOWS"
+    def self.token_hash(token, cost = nil)
+      cost ||= DeviseTokenAuth.token_cost
+      BCrypt::Password.create(token, cost: cost)
+    end
+
+    # Returns the value of time as an integer number of seconds. Takes one argument.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.expiry
+    #   => 1518983359
+    #   DeviseTokenAuth::TokenFactory.expiry(10)
+    #   => 1517773781
+    def self.expiry(lifespan = nil)
+      lifespan ||= DeviseTokenAuth.token_lifespan
+      (Time.zone.now + lifespan).to_i
+    end
+
+    # Generates a random URL-safe string.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.secure_string
+    #   => "ADBoIaqXsEDnxIpOuumrTA"
+    def self.secure_string
+      # https://ruby-doc.org/stdlib-2.5.0/libdoc/securerandom/rdoc/Random/Formatter.html#method-i-urlsafe_base64
+      SecureRandom.urlsafe_base64
+    end
+
+    # Returns true if token hash is a valid token hash.
+    # Example:
+    #   token_hash = "$2a$10$ArjX0tskRIa5Z/Tmapy59OCiAXLStfhrCiaDz.8fCb6hnX1gJ0p/2"
+    #   DeviseTokenAuth::TokenFactory.valid_token_hash?(token_hash)
+    #   => true
+    def self.valid_token_hash?(token_hash)
+      !!BCrypt::Password.valid_hash?(token_hash)
+    end
+
+    # Compares a potential token against the token hash. Returns true if the token is the original token, false otherwise.
+    # Example:
+    #   token = "4wZ9gcc900rMQD1McpcSNA"
+    #   token_hash = "$2a$10$ArjX0tskRIa5Z/Tmapy59OCiAXLStfhrCiaDz.8fCb6hnX1gJ0p/2"
+    #   DeviseTokenAuth::TokenFactory.token_hash_is_token?(token_hash, token)
+    #   => true
+    def self.token_hash_is_token?(token_hash, token)
+      BCrypt::Password.new(token_hash).is_password?(token)
+    rescue StandardError
+      false
+    end
+
+    # Creates a token instance with instance variables equal nil.
+    # Example:
+    #   DeviseTokenAuth::TokenFactory.new
+    #   => #<struct DeviseTokenAuth::TokenFactory::Token client=nil, token=nil, token_hash=nil, expiry=nil>
+    def self.new
+      Token.new
+    end
+
+    Token = Struct.new(:client, :token, :token_hash, :expiry) do
+      # Sets all instance variables of the token to nil. It is faster than creating new empty token.
+      # Example:
+      #   token.clear!
+      #   => true
+      #   token
+      #   => #<struct DeviseTokenAuth::TokenFactory::Token client=nil, token=nil, token_hash=nil, expiry=nil>
+      def clear!
+        size.times { |i| self[i] = nil }
+        true
+      end
+
+      # Checks token attribute presence
+      # Example:
+      #   token.present?
+      #   => true
+      def present?
+        token.present?
+      end
+    end
+  end
+end

data/lib/devise_token_auth/url.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeviseTokenAuth::Url
 
   def self.generate(url, params = {})
@@ -5,19 +7,24 @@ module DeviseTokenAuth::Url
 
     res = "#{uri.scheme}://#{uri.host}"
     res += ":#{uri.port}" if (uri.port && uri.port != 80 && uri.port != 443)
-    res += "#{uri.path}" if uri.path
+    res += uri.path.to_s if uri.path
     query = [uri.query, params.to_query].reject(&:blank?).join('&')
     res += "?#{query}"
     res += "##{uri.fragment}" if uri.fragment
+    # repeat any query params after the fragment to deal with Angular eating any pre fragment query params, used
+    # in the reset password redirect url
+    res += "?#{query}" if uri.fragment
 
-    return res
+    res
   end
 
   def self.whitelisted?(url)
-    url.nil? || !!DeviseTokenAuth.redirect_whitelist.find { |pattern| !!Wildcat.new(pattern).match(url) }
+    url.nil? || \
+      !!DeviseTokenAuth.redirect_whitelist.find do |pattern|
+        !!Wildcat.new(pattern).match(url)
+      end
   end
 
-
   # wildcard convenience class
   class Wildcat
     def self.parse_to_regex(str)

data/lib/devise_token_auth/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeviseTokenAuth
-  VERSION = '0.1.43'
+  VERSION = '1.2.0'.freeze
 end

data/lib/devise_token_auth.rb

@@ -1,8 +1,14 @@
-require "devise"
-require "devise_token_auth/engine"
-require "devise_token_auth/controllers/helpers"
-require "devise_token_auth/controllers/url_helpers"
-require "devise_token_auth/url"
+# frozen_string_literal: true
+
+require 'devise'
 
 module DeviseTokenAuth
 end
+
+require 'devise_token_auth/engine'
+require 'devise_token_auth/controllers/helpers'
+require 'devise_token_auth/controllers/url_helpers'
+require 'devise_token_auth/url'
+require 'devise_token_auth/errors'
+require 'devise_token_auth/blacklist'
+require 'devise_token_auth/token_factory'

data/lib/generators/devise_token_auth/USAGE

@@ -8,14 +8,14 @@ Arguments:
              # 'User'
   MOUNT_PATH # The path at which to mount the authentication routes. Default is
              # 'auth'. More detail documentation is here:
-             # https://github.com/lynndylanhurley/devise_token_auth#usage-tldr
+             # https://devise-token-auth.gitbook.io/devise-token-auth/usage
 
 Example:
   rails generate devise_token_auth:install User auth
 
   This will create:
       config/initializers/devise_token_auth.rb
-      db/migrate/<%= Time.now.utc.strftime("%Y%m%d%H%M%S") %>_create_devise_token_auth_create_users.rb
+      db/migrate/<%= Time.zone.now.utc.strftime("%Y%m%d%H%M%S") %>_create_devise_token_auth_create_users.rb
       app/models/user.rb
 
   If 'app/models/user.rb' already exists, the following line will be inserted

data/lib/generators/devise_token_auth/install_generator.rb

@@ -1,132 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'install_generator_helpers'
+
 module DeviseTokenAuth
   class InstallGenerator < Rails::Generators::Base
     include Rails::Generators::Migration
+    include DeviseTokenAuth::InstallGeneratorHelpers
 
-    source_root File.expand_path('../templates', __FILE__)
-
-    argument :user_class, type: :string, default: "User"
-    argument :mount_path, type: :string, default: 'auth'
-
-    def create_initializer_file
-      copy_file("devise_token_auth.rb", "config/initializers/devise_token_auth.rb")
-    end
+    class_option :primary_key_type, type: :string, desc: 'The type for primary key'
 
     def copy_migrations
-      if self.class.migration_exists?("db/migrate", "devise_token_auth_create_#{ user_class.underscore }")
-        say_status("skipped", "Migration 'devise_token_auth_create_#{ user_class.underscore }' already exists")
+      if self.class.migration_exists?('db/migrate', "devise_token_auth_create_#{user_class.pluralize.gsub('::','').underscore}")
+        say_status('skipped', "Migration 'devise_token_auth_create_#{user_class.pluralize.gsub('::','').underscore}' already exists")
       else
         migration_template(
-          "devise_token_auth_create_users.rb.erb",
-          "db/migrate/devise_token_auth_create_#{ user_class.pluralize.underscore }.rb"
+          'devise_token_auth_create_users.rb.erb',
+          "db/migrate/devise_token_auth_create_#{user_class.pluralize.gsub('::','').underscore}.rb"
         )
       end
     end
 
     def create_user_model
-      fname = "app/models/#{ user_class.underscore }.rb"
-      unless File.exist?(File.join(destination_root, fname))
-        template("user.rb", fname)
-      else
-        inclusion = "include DeviseTokenAuth::Concerns::User"
-        unless parse_file_for_line(fname, inclusion)
-          
-          active_record_needle = (Rails::VERSION::MAJOR == 5) ? 'ApplicationRecord' : 'ActiveRecord::Base'
-          inject_into_file fname, after: "class #{user_class} < #{active_record_needle}\n" do <<-'RUBY'
-  # Include default devise modules.
-  devise :database_authenticatable, :registerable,
-          :recoverable, :rememberable, :trackable, :validatable,
-          :confirmable, :omniauthable
-  include DeviseTokenAuth::Concerns::User
-          RUBY
-          end
-        end
-      end
-    end
-
-    def include_controller_concerns
-      fname = "app/controllers/application_controller.rb"
-      line  = "include DeviseTokenAuth::Concerns::SetUserByToken"
-
+      fname = "app/models/#{user_class.underscore}.rb"
       if File.exist?(File.join(destination_root, fname))
-        if parse_file_for_line(fname, line)
-          say_status("skipped", "Concern is already included in the application controller.")
-        elsif is_rails_api?
-          inject_into_file fname, after: "class ApplicationController < ActionController::API\n" do <<-'RUBY'
-  include DeviseTokenAuth::Concerns::SetUserByToken
-          RUBY
-          end
-        else
-          inject_into_file fname, after: "class ApplicationController < ActionController::Base\n" do <<-'RUBY'
-  include DeviseTokenAuth::Concerns::SetUserByToken
-          RUBY
-          end
-        end
-      else
-        say_status("skipped", "app/controllers/application_controller.rb not found. Add 'include DeviseTokenAuth::Concerns::SetUserByToken' to any controllers that require authentication.")
-      end
-    end
-
-    def add_route_mount
-      f    = "config/routes.rb"
-      str  = "mount_devise_token_auth_for '#{user_class}', at: '#{mount_path}'"
-
-      if File.exist?(File.join(destination_root, f))
-        line = parse_file_for_line(f, "mount_devise_token_auth_for")
-
-        unless line
-          line = "Rails.application.routes.draw do"
-          existing_user_class = false
-        else
-          existing_user_class = true
-        end
+        inclusion = 'include DeviseTokenAuth::Concerns::User'
+        unless parse_file_for_line(fname, inclusion)
 
-        if parse_file_for_line(f, str)
-          say_status("skipped", "Routes already exist for #{user_class} at #{mount_path}")
-        else
-          insert_after_line(f, line, str)
-
-          if existing_user_class
-            scoped_routes = ""+
-              "as :#{user_class.underscore} do\n"+
-              "    # Define routes for #{user_class} within this block.\n"+
-              "  end\n"
-            insert_after_line(f, str, scoped_routes)
+          active_record_needle = (Rails::VERSION::MAJOR >= 5) ? 'ApplicationRecord' : 'ActiveRecord::Base'
+          inject_into_file fname, after: "class #{user_class} < #{active_record_needle}\n" do <<-'RUBY'
+            # Include default devise modules.
+            devise :database_authenticatable, :registerable,
+                    :recoverable, :rememberable, :trackable, :validatable,
+                    :confirmable, :omniauthable
+            include DeviseTokenAuth::Concerns::User
+            RUBY
           end
         end
       else
-        say_status("skipped", "config/routes.rb not found. Add \"mount_devise_token_auth_for '#{user_class}', at: '#{mount_path}'\" to your routes file.")
+        template('user.rb.erb', fname)
       end
     end
 
     private
 
     def self.next_migration_number(path)
-      Time.now.utc.strftime("%Y%m%d%H%M%S")
-    end
-
-    def insert_after_line(filename, line, str)
-      gsub_file filename, /(#{Regexp.escape(line)})/mi do |match|
-        "#{match}\n  #{str}"
-      end
-    end
-
-    def parse_file_for_line(filename, str)
-      match = false
-
-      File.open(File.join(destination_root, filename)) do |f|
-        f.each_line do |line|
-          if line =~ /(#{Regexp.escape(str)})/mi
-            match = line
-          end
-        end
-      end
-      match
-    end
-
-    def is_rails_api?
-      fname = "app/controllers/application_controller.rb"
-      line = "class ApplicationController < ActionController::API"
-      parse_file_for_line(fname, line)
+      Time.zone.now.utc.strftime('%Y%m%d%H%M%S')
     end
 
     def json_supported_database?
@@ -156,5 +74,18 @@ module DeviseTokenAuth
     def database_version
       ActiveRecord::Base.connection.select_value('SELECT VERSION()')
     end
+
+    def rails_5_or_newer?
+      Rails::VERSION::MAJOR >= 5
+    end
+
+    def primary_key_type
+      primary_key_string if rails_5_or_newer?
+    end
+
+    def primary_key_string
+      key_string = options[:primary_key_type]
+      ", id: :#{key_string}" if key_string
+    end
   end
 end

data/lib/generators/devise_token_auth/install_generator_helpers.rb

@@ -0,0 +1,98 @@
+module DeviseTokenAuth
+  module InstallGeneratorHelpers
+    class << self
+      def included(mod)
+        mod.class_eval do
+          source_root File.expand_path('templates', __dir__)
+
+          argument :user_class, type: :string, default: 'User'
+          argument :mount_path, type: :string, default: 'auth'
+
+          def create_initializer_file
+            copy_file('devise_token_auth.rb', 'config/initializers/devise_token_auth.rb')
+          end
+
+          def include_controller_concerns
+            fname = 'app/controllers/application_controller.rb'
+            line  = 'include DeviseTokenAuth::Concerns::SetUserByToken'
+
+            if File.exist?(File.join(destination_root, fname))
+              if parse_file_for_line(fname, line)
+                say_status('skipped', 'Concern is already included in the application controller.')
+              elsif is_rails_api?
+                inject_into_file fname, after: "class ApplicationController < ActionController::API\n" do <<-'RUBY'
+        include DeviseTokenAuth::Concerns::SetUserByToken
+                RUBY
+                end
+              else
+                inject_into_file fname, after: "class ApplicationController < ActionController::Base\n" do <<-'RUBY'
+        include DeviseTokenAuth::Concerns::SetUserByToken
+                RUBY
+                end
+              end
+            else
+              say_status('skipped', "app/controllers/application_controller.rb not found. Add 'include DeviseTokenAuth::Concerns::SetUserByToken' to any controllers that require authentication.")
+            end
+          end
+
+          def add_route_mount
+            f    = 'config/routes.rb'
+            str  = "mount_devise_token_auth_for '#{user_class}', at: '#{mount_path}'"
+
+            if File.exist?(File.join(destination_root, f))
+              line = parse_file_for_line(f, 'mount_devise_token_auth_for')
+
+              if line
+                existing_user_class = true
+              else
+                line = 'Rails.application.routes.draw do'
+                existing_user_class = false
+              end
+
+              if parse_file_for_line(f, str)
+                say_status('skipped', "Routes already exist for #{user_class} at #{mount_path}")
+              else
+                insert_after_line(f, line, str)
+
+                if existing_user_class
+                  scoped_routes = ''\
+                    "as :#{user_class.underscore} do\n"\
+                    "    # Define routes for #{user_class} within this block.\n"\
+                    "  end\n"
+                  insert_after_line(f, str, scoped_routes)
+                end
+              end
+            else
+              say_status('skipped', "config/routes.rb not found. Add \"mount_devise_token_auth_for '#{user_class}', at: '#{mount_path}'\" to your routes file.")
+            end
+          end
+
+          private
+
+          def insert_after_line(filename, line, str)
+            gsub_file filename, /(#{Regexp.escape(line)})/mi do |match|
+              "#{match}\n  #{str}"
+            end
+          end
+
+          def parse_file_for_line(filename, str)
+            match = false
+
+            File.open(File.join(destination_root, filename)) do |f|
+              f.each_line do |line|
+                match = line if line =~ /(#{Regexp.escape(str)})/mi
+              end
+            end
+            match
+          end
+
+          def is_rails_api?
+            fname = 'app/controllers/application_controller.rb'
+            line = 'class ApplicationController < ActionController::API'
+            parse_file_for_line(fname, line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/devise_token_auth/install_mongoid_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'install_generator_helpers'
+
+module DeviseTokenAuth
+  class InstallMongoidGenerator < Rails::Generators::Base
+    include DeviseTokenAuth::InstallGeneratorHelpers
+
+    def create_user_model
+      fname = "app/models/#{user_class.underscore}.rb"
+      if File.exist?(File.join(destination_root, fname))
+        inclusion = 'include DeviseTokenAuth::Concerns::User'
+        unless parse_file_for_line(fname, inclusion)
+          inject_into_file fname, before: /end\s\z/ do <<-'RUBY'
+
+  include Mongoid::Locker
+
+  field :locker_locked_at, type: Time
+  field :locker_locked_until, type: Time
+
+  locker locked_at_field: :locker_locked_at,
+         locked_until_field: :locker_locked_until
+
+  ## Required
+  field :provider, type: String
+  field :uid,      type: String, default: ''
+
+  ## Tokens
+  field :tokens, type: Hash, default: {}
+
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :validatable
+  include DeviseTokenAuth::Concerns::User
+
+  index({ uid: 1, provider: 1}, { name: 'uid_provider_index', unique: true, background: true })
+            RUBY
+          end
+        end
+      else
+        template('user_mongoid.rb.erb', fname)
+      end
+    end
+  end
+end

data/lib/generators/devise_token_auth/install_views_generator.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module DeviseTokenAuth
   class InstallViewsGenerator < Rails::Generators::Base
-    source_root File.expand_path('../../../../app/views/devise/mailer', __FILE__)
+    source_root File.expand_path('../../../app/views/devise/mailer', __dir__)
 
     def copy_mailer_templates
       copy_file(
-        "confirmation_instructions.html.erb",
-        "app/views/devise/mailer/confirmation_instructions.html.erb"
+        'confirmation_instructions.html.erb',
+        'app/views/devise/mailer/confirmation_instructions.html.erb'
       )
       copy_file(
-        "reset_password_instructions.html.erb",
-        "app/views/devise/mailer/reset_password_instructions.html.erb"
+        'reset_password_instructions.html.erb',
+        'app/views/devise/mailer/reset_password_instructions.html.erb'
       )
     end
   end

data/lib/generators/devise_token_auth/templates/devise_token_auth.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 DeviseTokenAuth.setup do |config|
   # By default the authorization headers will change after each request. The
   # client is responsible for keeping track of the changing tokens. Change
@@ -9,6 +11,11 @@ DeviseTokenAuth.setup do |config|
   # determines how long tokens will remain valid after they are issued.
   # config.token_lifespan = 2.weeks
 
+  # Limiting the token_cost to just 4 in testing will increase the performance of
+  # your test suite dramatically. The possible cost value is within range from 4
+  # to 31. It is recommended to not use a value more than 10 in other environments.
+  config.token_cost = Rails.env.test? ? 4 : 10
+
   # Sets the max number of concurrent devices per user, which is 10 by default.
   # After this limit is reached, the oldest tokens will be removed.
   # config.max_number_of_devices = 10
@@ -45,4 +52,9 @@ DeviseTokenAuth.setup do |config|
   # If, however, you wish to integrate with legacy Devise authentication, you can
   # do so by enabling this flag. NOTE: This feature is highly experimental!
   # config.enable_standard_devise_support = false
+
+  # By default DeviseTokenAuth will not send confirmation email, even when including
+  # devise confirmable module. If you want to use devise confirmable module and
+  # send email, set it to true. (This is a setting for compatibility)
+  # config.send_confirmation_email = true
 end

data/lib/generators/devise_token_auth/templates/devise_token_auth_create_users.rb.erb

@@ -1,6 +1,7 @@
-class DeviseTokenAuthCreate<%= user_class.pluralize %> < ActiveRecord::Migration<%= "[#{Rails::VERSION::STRING[0..2]}]" if Rails::VERSION::MAJOR > 4 %>
+class DeviseTokenAuthCreate<%= user_class.pluralize.gsub("::","") %> < ActiveRecord::Migration<%= "[#{Rails::VERSION::STRING[0..2]}]" if Rails::VERSION::MAJOR > 4 %>
   def change
-    create_table(:<%= user_class.pluralize.underscore %>) do |t|
+    <% table_name = @user_class.pluralize.gsub("::","").underscore %>
+    create_table(:<%= table_name %><%= primary_key_type %>) do |t|
       ## Required
       t.string :provider, :null => false, :default => "email"
       t.string :uid, :null => false, :default => ""
@@ -16,13 +17,6 @@ class DeviseTokenAuthCreate<%= user_class.pluralize %> < ActiveRecord::Migration
       ## Rememberable
       t.datetime :remember_created_at
 
-      ## Trackable
-      t.integer  :sign_in_count, :default => 0, :null => false
-      t.datetime :current_sign_in_at
-      t.datetime :last_sign_in_at
-      t.string   :current_sign_in_ip
-      t.string   :last_sign_in_ip
-
       ## Confirmable
       t.string   :confirmation_token
       t.datetime :confirmed_at
@@ -46,10 +40,10 @@ class DeviseTokenAuthCreate<%= user_class.pluralize %> < ActiveRecord::Migration
       t.timestamps
     end
 
-    add_index :<%= user_class.pluralize.underscore %>, :email,                unique: true
-    add_index :<%= user_class.pluralize.underscore %>, [:uid, :provider],     unique: true
-    add_index :<%= user_class.pluralize.underscore %>, :reset_password_token, unique: true
-    add_index :<%= user_class.pluralize.underscore %>, :confirmation_token,   unique: true
-    # add_index :<%= user_class.pluralize.underscore %>, :unlock_token,       unique: true
+    add_index :<%= table_name %>, :email,                unique: true
+    add_index :<%= table_name %>, [:uid, :provider],     unique: true
+    add_index :<%= table_name %>, :reset_password_token, unique: true
+    add_index :<%= table_name %>, :confirmation_token,   unique: true
+    # add_index :<%= table_name %>, :unlock_token,         unique: true
   end
 end

data/lib/generators/devise_token_auth/templates/user.rb.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class <%= user_class %> < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :validatable
+  include DeviseTokenAuth::Concerns::User
+end