devise-api 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52cab446a0341887a91a1fc53e0f9ba2d6d70ebe18c7c3ccadf502eccd5bc0f5
-  data.tar.gz: c633f441ac5967666f9c703812aa126161748d3e7d11ea7060d6c813633c8e3f
+  metadata.gz: 35aa72da6fbb296fb21b21ec8b0512f54c4061b253c30c0e4292223fec052d00
+  data.tar.gz: 7f960c887b37beb79bd01f5ecea667d8f19007b865207d21c47881f7e057d104
 SHA512:
-  metadata.gz: 8a2d7924e04bd2789f73f0aba892fcb3919b17736c2b33c97c007ba2a3d1b619b3eb80e66f600a77b352cc20069a8b82a6b03b0ea9340e2640a8c76ff3203366
-  data.tar.gz: 4dea11a94ce670c76ef74622f920e42563aa421b3061d52583f44b2709402255045be520e8613e910d5865779f044b56fdb6d0837e48ff8ec916af1f2fab345c
+  metadata.gz: fe4d8f38cecf1d6cb38a79caa0e7ac47fca859789bae2f2e8de612757747f11a72220c5465a9d58f73d206d33006eb85ac8352e723a0467a82f4fc7f87efc90a
+  data.tar.gz: 3c91b3f5800f9b6a3e7684841dc29c7ee517058584a9ea15a890b2d1ff2000b5b21b451108d7c68eaf5a88f431ec7b11bf4abf684cbdd25f9c733d7faa785011

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -27,3 +27,6 @@ Metrics/AbcSize:
 
 Metrics/BlockLength:
   Max: 30
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'spec/dummy/db/**/*'

data/Gemfile

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 # Specify your gem's dependencies in devise-api.gemspec
 gemspec
@@ -8,8 +9,8 @@ gemspec
 # Rake is a Make-like program implemented in Ruby [https://github.com/ruby/rake]
 gem 'rake', '~> 13.0'
 
-# Minitest provides a complete suite of testing facilities supporting [https://github.com/minitest/minitest]
-gem 'minitest', '~> 5.0'
+# Behaviour Driven Development for Ruby [https://github.com/rspec/rspec-metagem]
+gem 'rspec', '~> 3.0'
 
 # RuboCop is a Ruby code style checking and code formatting tool [https://github.com/rubocop/rubocop]
 gem 'rubocop', '~> 1.21'
@@ -19,3 +20,30 @@ gem 'awesome_print'
 
 # Pry is a runtime developer console and IRB alternative with powerful introspection capabilities [https://github.com/pry/pry]
 gem 'pry', '~> 0.14.1'
+
+# The original asset pipeline for Rails [https://github.com/rails/sprockets-rails]
+gem 'sprockets-rails'
+
+# Use sqlite3 as the database for Active Record
+gem 'sqlite3', '~> 1.4'
+
+# Use the Puma web server [https://github.com/puma/puma]
+gem 'puma', '~> 5.0'
+
+# A library for setting up Ruby objects as test data [https://github.com/thoughtbot/factory_bot]
+gem 'factory_bot', '~> 6.2', '>= 6.2.1'
+
+# A library for generating fake data such as names, addresses, and phone numbers [https://github.com/faker-ruby/faker]
+gem 'faker', '~> 3.1'
+
+# Strategies for cleaning databases in Ruby. Can be used to ensure a clean state for testing [https://github.com/DatabaseCleaner/database_cleaner]
+gem 'database_cleaner', '~> 2.0', '>= 2.0.1'
+
+# RSpec for Rails 5+ [https://github.com/rspec/rspec-rails]
+gem 'rspec-rails', '~> 6.0', '>= 6.0.1'
+
+# RSpec runner and formatters [https://github.com/rspec/rspec-core]
+gem 'rspec-core'
+
+# Common code needed by the other RSpec gems. Not intended for direct use [https://github.com/rspec/rspec-support]
+gem 'rspec-support'

data/Gemfile.lock

@@ -3,6 +3,10 @@ PATH
   specs:
     devise-api (0.0.0)
       devise (>= 4.7.2)
+      dry-configurable (~> 1.0, >= 1.0.1)
+      dry-initializer (>= 3.1.1)
+      dry-monads (>= 1.6.0)
+      dry-types (>= 1.7.0)
       rails (>= 6.0.0)
 
 GEM
@@ -80,6 +84,12 @@ GEM
     coderay (1.1.3)
     concurrent-ruby (1.1.10)
     crass (1.0.6)
+    database_cleaner (2.0.1)
+      database_cleaner-active_record (~> 2.0.0)
+    database_cleaner-active_record (2.0.1)
+      activerecord (>= 5.a)
+      database_cleaner-core (~> 2.0.0)
+    database_cleaner-core (2.0.1)
     date (3.3.3)
     devise (4.8.1)
       bcrypt (~> 3.0)
@@ -87,7 +97,34 @@ GEM
       railties (>= 4.1.0)
       responders
       warden (~> 1.2.3)
+    diff-lcs (1.5.0)
+    dry-configurable (1.0.1)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-core (1.0.0)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-inflector (1.0.0)
+    dry-initializer (3.1.1)
+    dry-logic (1.5.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-monads (1.6.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-types (1.7.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      dry-inflector (~> 1.0, < 2)
+      dry-logic (>= 1.4, < 2)
+      zeitwerk (~> 2.6)
     erubi (1.12.0)
+    factory_bot (6.2.1)
+      activesupport (>= 5.0.0)
+    faker (3.1.0)
+      i18n (>= 1.8.11, < 2)
     globalid (1.0.0)
       activesupport (>= 5.0)
     i18n (1.12.0)
@@ -123,9 +160,11 @@ GEM
     parallel (1.22.1)
     parser (3.2.0.0)
       ast (~> 2.4.1)
-    pry (0.14.1)
+    pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    puma (5.6.5)
+      nio4r (~> 2.0)
     racc (1.6.2)
     rack (2.2.5)
     rack-test (2.0.2)
@@ -163,6 +202,27 @@ GEM
       actionpack (>= 5.0)
       railties (>= 5.0)
     rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-rails (6.0.1)
+      actionpack (>= 6.1)
+      activesupport (>= 6.1)
+      railties (>= 6.1)
+      rspec-core (~> 3.11)
+      rspec-expectations (~> 3.11)
+      rspec-mocks (~> 3.11)
+      rspec-support (~> 3.11)
+    rspec-support (3.12.0)
     rubocop (1.42.0)
       json (~> 2.3)
       parallel (~> 1.10)
@@ -176,6 +236,14 @@ GEM
     rubocop-ast (1.24.1)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
+    sprockets (4.2.0)
+      concurrent-ruby (~> 1.0)
+      rack (>= 2.2.4, < 4)
+    sprockets-rails (3.4.2)
+      actionpack (>= 5.2)
+      activesupport (>= 5.2)
+      sprockets (>= 3.0.0)
+    sqlite3 (1.6.0-arm64-darwin)
     thor (1.2.1)
     timeout (0.3.1)
     tzinfo (2.0.5)
@@ -189,15 +257,25 @@ GEM
     zeitwerk (2.6.6)
 
 PLATFORMS
+  arm64-darwin-21
   arm64-darwin-22
 
 DEPENDENCIES
   awesome_print
+  database_cleaner (~> 2.0, >= 2.0.1)
   devise-api!
-  minitest (~> 5.0)
+  factory_bot (~> 6.2, >= 6.2.1)
+  faker (~> 3.1)
   pry (~> 0.14.1)
+  puma (~> 5.0)
   rake (~> 13.0)
+  rspec (~> 3.0)
+  rspec-core
+  rspec-rails (~> 6.0, >= 6.0.1)
+  rspec-support
   rubocop (~> 1.21)
+  sprockets-rails
+  sqlite3 (~> 1.4)
 
 BUNDLED WITH
    2.4.3

data/README.md

@@ -5,17 +5,16 @@
 ![Ruby Version](https://img.shields.io/badge/ruby_version->=_2.7.0-blue.svg)
 
 # Devise API
-
-The `devise-api` gem is a convenient way to add authentication to your Ruby on Rails API application using the [devise](https://github.com/heartcombo/devise) gem. It provides support for access tokens and refresh tokens, which allow you to authenticate API requests and keep the user's session active for a longer period of time.
+The devise-api gem is a convenient way to add authentication to your Ruby on Rails application using the devise gem. It provides support for access tokens and refresh tokens, which allow you to authenticate API requests and keep the user's session active for a longer period of time on the client side. It can be installed by adding the gem to your Gemfile, running migrations, and adding the :api module to your devise model. The gem is fully configurable, allowing you to set things like token expiration times and token generators.
 
 Here's how it works:
 
-- When a user logs in to your API application, the `devise-api` gem generates an access token and a refresh token.
+- When a user logs in to your Rails application, the `devise-api` gem generates an access token and a refresh token.
 - The access token is included in the API request headers and is used to authenticate the user on each subsequent request.
 - The refresh token is stored on the client side (e.g. in a browser cookie or on a mobile device) and is used to obtain a new access token when the original access token expires.
 - This allows the user to remain logged in and make API requests without having to constantly re-enter their login credentials.
 
-Overall, the `devise-api` gem is a useful tool for adding secure authentication to your Ruby on Rails API application.
+Overall, the `devise-api` gem is a useful tool for adding secure authentication to your Ruby on Rails application.
 
 ## Installation
 
@@ -34,9 +33,190 @@ If bundler is not being used to manage dependencies, install the gem by executin
 gem install devise-api
 ```
 
+After that, you need to generate relevant migrations and locales by executing:
+```bash
+$ rails generate devise_api:install
+```
+
+This will introduce two changes:
+- Locale files in `config/locales/devise_api.en.yml`
+- Migration file in `db/migrate` to create devise api tokens table
+
+Now you're ready to run the migrations:
+```bash
+$ rails db:migrate
+```
+
+Finally, you need to add `:api` module to your devise model. For example:
+```ruby
+class User < ApplicationRecord
+  devise :database_authenticatable, 
+         :registerable, 
+         :recoverable,
+         :rememberable,
+         :validatable,
+         :api # <--- Add this module
+end
+```
+
+Your user model is now ready to use `devise-api` gem.
+
+## Configuration
+
+`devise-api` is a full configurable gem. You can configure it to your needs. Here is a basic usage example:
+
+```ruby
+# config/initializers/devise.rb
+Devise.setup do |config|
+  config.api.configure do |api|
+    # Access Token
+    api.access_token.expires_in = 1.hour
+    api.access_token.expires_in_infinite = ->(_resource_owner) { false }
+    api.access_token.generator = ->(_resource_owner) { Devise.friendly_token(60)) }
+
+
+    # Refresh Token
+    api.refresh_token.enabled = true
+    api.refresh_token.expires_in = 1.week
+    api.refresh_token.generator = ->(_resource_owner) { Devise.friendly_token(60)) }
+    api.refresh_token.expires_in_infinite = ->(_resource_owner) { false }
+
+
+    # Authorization
+    api.authorization.key = 'Authorization'
+    api.authorization.scheme = 'Bearer'
+    api.authorization.location = :both # :header or :params or :both
+    api.authorization.params_key = 'access_token'
+
+
+    # Base classes
+    api.base_token_model = 'Devise::Api::Token'
+    api.base_controller = '::DeviseController'
+
+
+    # After successful callbacks
+    api.after_successful_sign_in = ->(_resource_owner, _token, _request) { }
+    api.after_successful_sign_up = ->(_resource_owner, _token, _request) { }
+    api.after_successful_refresh = ->(_resource_owner, _token, _request) { }
+    api.after_successful_revoke = ->(_resource_owner, _token, _request) { }
+
+
+    # Before callbacks
+    api.before_sign_in = ->(_params, _request, _resource_class) { }
+    api.before_sign_up = ->(_params, _request, _resource_class) { }
+    api.before_refresh = ->(_params, _request, _resource_class) { }
+    api.before_revoke = ->(_params, _request, _resource_class) { }
+  end
+end
+```
+
+## Routes
+
+You can configure the tokens routes with the orginally `devise_for` method. For example:
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  devise_for :customers, 
+             controllers: { tokens: 'customers/api/tokens' }
+end
+```
+
 ## Usage
+`devise-api` module works with `:lockable` and `:confirmable` modules. It also works with `:trackable` module.
+
+`devise-api` provides a set of controllers and helpers to help you implement authentication in your Rails application. Here's a quick overview of the available controllers and helpers:
+
+- [Devise::Api::TokensController](https://github.com/nejdetkadir/devise-api/tree/main/app/controllers/devise/api/tokens_controller.rb) - This controller is responsible for generating access tokens and refresh tokens. It also provides actions for refreshing access tokens and revoking refresh tokens.
+
+- [Devise::Api::Token](https://github.com/nejdetkadir/devise-api/tree/main/lib/devise/api/token.rb) - This model is responsible for storing access tokens and refresh tokens in the database.
+
+- [Devise::Api::Responses::ErrorResponse](https://github.com/nejdetkadir/devise-api/tree/main/lib/devise/api/responses/error_response.rb) - This class is responsible for generating error responses. It also provides a set of error types and helpers to help you implement error responses in your Rails application.
+
+- [Devise::Api::Responses::TokenResponse](https://github.com/nejdetkadir/devise-api/tree/main/lib/devise/api/responses/token_response.rb) - This class is responsible for generating token responses. It also provides actions for generating access tokens and refresh tokens for each action.
+
+## Overriding Responses
+You can prepend your decorators to the response classes to override the default responses. For example:
+```ruby
+# app/lib/devise/api/responses/token_response_decorator.rb
+module Devise::Api::Responses::TokenResponseDecorator
+  def body
+    return default_body.merge({ roles: resource_owner.roles })
+  end
+end
+```
+
+Then you need to prepend your decorator to the response class. For example:
+
+```ruby
+# config/initializers/devise.rb
+Devise.setup do |config|
+end
 
-TODO: Write usage instructions here
+Devise::Api::Responses::TokenResponse.prepend Devise::Api::Responses::TokenResponseDecorator
+```
+
+## Using helpers
+`devise-api` provides a set of helpers to help you implement authentication in your Rails application. Here's a quick overview of the available helpers:
+
+Example:
+```ruby
+# app/controllers/api/v1/orders_controller.rb
+class Api::V1::OrdersController < YourBaseController
+  skip_before_action :verify_authenticity_token, raise: false  
+  before_action :authenticate_devise_api_token!
+
+  def index
+    render json: current_devise_api_user.orders, status: :ok
+  end
+
+  def show
+    devise_api_token = current_devise_api_token
+    render json: devise_api_token.resource_owner.orders.find(params[:id]), status: :ok
+  end
+end
+```
+
+## Using devise base services
+`devise-api` provides a set of base services to help you implement authentication in your Rails application. Here's a quick overview of the available services:
+
+- [Devise::Api::BaseService](https://github.com/nejdetkadir/devise-api/tree/main/app/services/devise/api/base_service.rb) - This service is useful for creating and updating resources. It is inherited by the following gems.
+- [dry-monads](https://dry-rb.org/gems/dry-monads)
+- [dry-types](https://dry-rb.org/gems/dry-types)
+- [dry-initializer](https://dry-rb.org/gems/dry-initializer)
+
+You can create a service by inheriting the `Devise::Api::BaseService` class. For example:
+```ruby
+# app/services/devise/api/tokens_service/v2/create.rb
+module Devise::Api::TokensService::V2
+  class Create < Devise::Api::BaseService
+    option :params, type: Types::Hash, reader: true
+    option :resource_class, type: Types::Class, reader: true
+
+    def call
+      ...
+
+      Success(resource)
+    end
+  end
+end
+```
+
+Then you can call the service in your controller. For example:
+```ruby
+# app/controllers/api/v1/tokens_controller.rb
+class Api::V1::TokensController < YourBaseController
+  skip_before_action :verify_authenticity_token, raise: false
+
+  def create
+    service = Devise::Api::TokensService::V2::Create.call(params: params, resource_class: Customer || resource_class)
+    if service.success?
+      render json: service.success, status: :created
+    else
+      render json: service.failure, status: :unprocessable_entity
+    end
+  end
+end
+```
 
 ## Development
 

data/Rakefile

@@ -1,16 +1,12 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  t.test_files = FileList['test/**/test_*.rb']
-end
+RSpec::Core::RakeTask.new(:rspec)
 
 require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 
-task default: %i[test rubocop]
+task default: %i[rspec rubocop]

data/app/controllers/devise/api/tokens_controller.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Devise
+  module Api
+    class TokensController < Devise.api.config.base_controller.constantize
+      skip_before_action :verify_authenticity_token, raise: false
+      before_action :authenticate_devise_api_token!, only: %i[info refresh]
+
+      respond_to :json
+
+      # rubocop:disable Metrics/AbcSize
+      def sign_up
+        Devise.api.config.before_sign_up.call(sign_up_params, request, resource_class)
+
+        service = Devise::Api::ResourceOwnerService::SignUp.new(params: sign_up_params,
+                                                                resource_class: resource_class).call
+
+        if service.success?
+          token = service.success
+
+          call_devise_trackable!(token.resource_owner)
+
+          token_response = Devise::Api::Responses::TokenResponse.new(request, token: token, action: __method__)
+
+          Devise.api.config.after_successful_sign_up.call(token.resource_owner, token, request)
+
+          return render json: token_response.body, status: token_response.status
+        end
+
+        error_response = Devise::Api::Responses::ErrorResponse.new(request,
+                                                                   resource_class: resource_class,
+                                                                   **service.failure)
+
+        render json: error_response.body, status: error_response.status
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def sign_in
+        Devise.api.config.before_sign_in.call(sign_in_params, request, resource_class)
+
+        service = Devise::Api::ResourceOwnerService::SignIn.new(params: sign_in_params,
+                                                                resource_class: resource_class).call
+
+        if service.success?
+          token = service.success
+
+          call_devise_trackable!(token.resource_owner)
+
+          token_response = Devise::Api::Responses::TokenResponse.new(request, token: service.success,
+                                                                              action: __method__)
+
+          Devise.api.config.after_successful_sign_in.call(token.resource_owner, token, request)
+
+          return render json: token_response.body, status: token_response.status
+        end
+
+        error_response = Devise::Api::Responses::ErrorResponse.new(request,
+                                                                   resource_class: resource_class,
+                                                                   **service.failure)
+
+        render json: error_response.body, status: error_response.status
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def info
+        token_response = Devise::Api::Responses::TokenResponse.new(request, token: current_devise_api_token,
+                                                                            action: __method__)
+
+        render json: token_response.body, status: token_response.status
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def revoke
+        Devise.api.config.before_revoke.call(current_devise_api_token, request)
+
+        service = Devise::Api::TokensService::Revoke.new(devise_api_token: current_devise_api_token).call
+
+        if service.success?
+          token_response = Devise::Api::Responses::TokenResponse.new(request, token: service.success,
+                                                                              action: __method__)
+
+          Devise.api.config.after_successful_revoke.call(service.success&.resource_owner, service.success, request)
+
+          return render json: token_response.body, status: token_response.status
+        end
+
+        error_response = Devise::Api::Responses::ErrorResponse.new(request,
+                                                                   resource_class: resource_class,
+                                                                   **service.failure)
+
+        render json: error_response.body, status: error_response.status
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def refresh
+        unless Devise.api.config.refresh_token.enabled
+          error_response = Devise::Api::Responses::ErrorResponse.new(request,
+                                                                     resource_class: resource_class,
+                                                                     error: :refresh_token_disabled)
+
+          return render json: error_response.body, status: error_response.status
+        end
+
+        Devise.api.config.before_refresh.call(current_devise_api_token, request)
+
+        service = Devise::Api::TokensService::Refresh.new(devise_api_token: current_devise_api_token).call
+
+        if service.success?
+          token_response = Devise::Api::Responses::TokenResponse.new(request, token: service.success,
+                                                                              action: __method__)
+
+          Devise.api.config.after_successful_refresh.call(service.success.resource_owner, service.success, request)
+
+          return render json: token_response.body, status: token_response.status
+        end
+
+        error_response = Devise::Api::Responses::ErrorResponse.new(request,
+                                                                   resource_class: resource_class,
+                                                                   **service.failure)
+
+        render json: error_response.body, status: error_response.status
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def sign_up_params
+        params.permit(*resource_class.authentication_keys,
+                      *::Devise::ParameterSanitizer::DEFAULT_PERMITTED_ATTRIBUTES[:sign_up]).to_h
+      end
+
+      def sign_in_params
+        params.permit(*resource_class.authentication_keys,
+                      *::Devise::ParameterSanitizer::DEFAULT_PERMITTED_ATTRIBUTES[:sign_in]).to_h
+      end
+
+      def call_devise_trackable!(resource_owner)
+        return unless resource_class.supported_devise_modules.trackable?
+
+        resource_owner.update_tracked_fields!(request)
+      end
+    end
+  end
+end

data/app/services/devise/api/base_service.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry/monads/all'
+require 'dry-initializer'
+require 'dry-types'
+
+module Types
+  include Dry.Types()
+end
+
+module Devise
+  module Api
+    class BaseService
+      extend Dry::Initializer
+
+      include Dry::Monads
+      include Dry::Monads::Do
+    end
+  end
+end

data/app/services/devise/api/resource_owner_service/authenticate.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Devise
+  module Api
+    module ResourceOwnerService
+      class Authenticate < Devise::Api::BaseService
+        option :params, type: Types::Hash
+        option :resource_class, type: Types::Class
+
+        def call
+          resource = resource_class.find_for_authentication(email: params[:email])
+          return Failure(error: :invalid_email, record: nil) if resource.blank?
+          return Failure(error: :invalid_authentication, record: resource) unless authenticate!(resource)
+
+          Success(resource)
+        end
+
+        private
+
+        def authenticate!(resource)
+          resource.valid_for_authentication? do
+            resource.valid_password?(params[:password])
+          end && resource.active_for_authentication?
+        end
+      end
+    end
+  end
+end

data/app/services/devise/api/resource_owner_service/sign_in.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Devise
+  module Api
+    module ResourceOwnerService
+      class SignIn < Devise::Api::BaseService
+        option :params, type: Types::Hash
+        option :resource_class, type: Types::Class
+
+        def call
+          resource_owner = yield call_authenticate_service
+          devise_api_token = yield call_create_devise_api_token_service(resource_owner)
+          resource_owner.reset_failed_attempts! if resource_owner.class.supported_devise_modules.lockable?
+
+          Success(devise_api_token)
+        end
+
+        private
+
+        def call_authenticate_service
+          Devise::Api::ResourceOwnerService::Authenticate.new(params: params,
+                                                              resource_class: resource_class).call
+        end
+
+        def call_create_devise_api_token_service(resource_owner)
+          Devise::Api::TokensService::Create.new(resource_owner: resource_owner).call
+        end
+      end
+    end
+  end
+end