class ExampleCommand
  prepend SimpleCommand
  def initialize(foo:)
    @foo = foo
  end
  def call
    @foo
  end
end

irb(main):010:0> ExampleCommand.call(foo: "bar")
/usr/local/bundle/gems/simple_command-0.1.0/lib/simple_command.rb:9: warning: Using the last argument as keyword parameters is deprecated; maybe ** should be added to the call
(irb):3: warning: The called method `initialize' is defined here
=> #<ExampleCommand:0x0000560f7af7f988 @foo="bar", @called=true, @result="bar">

expect(
  get_users(page: '-2')
).to eq(errors: { page: ["must be a positive number"] })
expected: {:errors=>{:page=>["must be a positive number"]}}
     got: {:errors=>{:page=>"must be a positive number"}}

load_users = LoadUsers.(params)
if load_users.success?
  render json: load_users.result
else
  render json: { errors: load_users.errors }
end

# SimpleCommand::Errors
load_users = LoadUsers.new
load_users.errors.add(:page, 'must be a positive number')
load_users.errors.add(:page, 'cannot be blank')
load_users.errors.as_json
=> {"page"=>"cannot be blank"}

# ActiveModel::Errors
user = User.new
user.errors.add(:email, 'is invalid')
user.errors.add(:email, 'cannot be blank')
user.errors.as_json
=> {:email=>["is invalid", "cannot be blank"]}

module Api
    module V1
        class AuthenticationController < ApplicationController
            skip_before_action :authenticate_request

            def authenticate
                command = AuthenticateUser.call(params[:username], params[:password])

                if command.success?
                    render json: {auth_token: command.result}
                else
                    render json: {error: command.errors }, status: :unauthorized
                end
            end
        end
    end
end

class AuthorizeApiRequest 
    prepend SimpleCommand 

    def initialize(headers = {}) 
        @headers = headers 
    end 

    def call 
        user 
    end 

    private 

    attr_reader :headers 

    def user 
        @user ||= User.find(decoded_auth_token[:user_id]) if decoded_auth_token 
        @user || errors.add(:token, 'Invalid token') && nil 
    end 

    def decoded_auth_token 
        @decoded_auth_token ||= JsonWebToken.decode(http_auth_header) 
    end 

    def http_auth_header 
        if headers['Authorization'].present? 
            return headers['Authorization'].split(' ').last 
        else 
            errors.add(:token, 'Missing token') 
        end 
        nil 
    end 
end

# app/commands/authorize_api_request.rb

class AuthorizeApiRequest
  prepend SimpleCommand

  def initialize(headers = {})
    @headers = headers
  end

  def call
    user
  end

  private

  attr_reader :headers

  def user
    @user ||= User.find(decoded_auth_token[:user_id]) if decoded_auth_token
    @user || errors.add(:token, 'Invalid token') && nil
  end

  def decoded_auth_token
    @decoded_auth_token ||= JsonWebToken.decode(http_auth_header)
  end

  def http_auth_header
    if headers['Authorization'].present?
      return headers['Authorization'].split(' ').last
    else
      errors.add(:token, 'Missing token')
    end
    nil
  end
end

# app/controllers/admin/authenticated_controller.rb

module Admin
  class AuthenticatedController < ApplicationController

    prepend SimpleCommand
    
    before_action :authenticate_request

    attr_reader :current_user

    private

    def authenticate_request
      @current_user = AuthorizeApiRequest.call(request.headers).result
      render json: { error: 'Not Authorized' }, status: 401 unless @current_user
    end

  end
end

#simple_command
Class AuthenticateUser
*
*
  errors.add :user_authentication, 'invalid credentials'
*
*
end
#controller
command = AuthenticateUser.call(params[:email], params[:password])

render json: command, status: 401, adapter: :json_api, serializer: ActiveModel::Serializer::ErrorSerializer