Performify

gem 'performify'

class ApplicationService < Performify::Base
  def authorize!(record)
    # you can put authorization logic here and use it from inherited services
  end
end

class ApplicationService < Performify::Base
  def authorize!(record, query = default_query, record_policy = nil)
    record_policy ||= policy(record)
    return if record_policy.public_send(query)

    raise Pundit::NotAuthorizedError, query: query, record: record, policy: record_policy
  end

  def default_query
    @default_query ||= "#{self.class.name.demodulize.underscore.to_sym}?"
  end

  def policy(record)
    @policy ||= Pundit.policy!(@current_user, record)
  end
end

module Users
  class Destroy < ApplicationService
    def execute!
      # current user is already available, so feel free to use it
      # to get user's context

      authorize! current_user unless force?

      # block passed into super's implementation will be executed
      # in transaction, so you can do multiple data operations, and final
      # result of this block will be used to determine result of execution

      super do
        if current_user.update(destroyed_at: Time.zone.now)
          current_user.comments.find_each do |c|
            s = Comments::Destroy.new(current_user, c)
            s.execute!

            # it's also ok to raise ActiveRecord::Rollback, it will be handled
            # gracefully as regular execution fail

            raise ActiveRecord::Rollback unless s.success?
          end
        end
      end
    end

    def force?
      # additional instance variables can be passed as named args into
      # initializer and accessed in service flow

      force.present?
    end
  end
end

service = Users::Destroy.new(current_user, force: true)
service.execute!
service.success? # or service.fail?

class Stripe::Create < ApplicationService
  attr_reader :subscription

  def execute!
    # here you can go to Stripe and create subscription for the user
    begin
      @subscription = Stripe::Subscription.create(
        customer: current_user.customer_id,
        plan: selected_plan.stripe_name,
      )

      # everything looks ok, success

      success!
   rescue Stripe::StripeError => e
      # something went wrong, let's notify developers and say that
      # service execution has been failed

     Airbrake.notify(e)
     fail!
   end
  end
end

module Passwords
  class Update < ApplicationService
    def execute!
      authorize! current_user

      super do
        current_user.update(password: password, password_confirmation: password_confirmation)
      end
    end

    # you can pass method name as a callback

    on_success :invalidate_sessions

    # or you can pass block instead of method name

    on_success { UserMailer.password_changed(current_user).deliver_later }

    private def invalidate_sessions
      # you can invalidate existing user's sessions here
    end
  end
end

module Users
  class Create
    schema do
      required(:email).filled(:str?)
    end

    def execute!
      # it will be impossible to call execution if provided arguments
      # did not pass validation
    end
  end
end

service = Users::Create.new(current_user, email: nil)
service.execute! # nothing happens here
service.success? # will be false because of validation
service.errors   # contains hash of errors

module Users
  class Create
    attr_reader :user

    schema do
      required(:email).filled(:str?)
    end

    def execute!
      user = User.new(email: email)
      authorize! user

      # Let's assume that user has additional validation of uniqueness on the
      # level of model, so in controller you need to check separately service's
      # errors and model's errors, right?

      super { user.save }
    end

    # So, we define on fail callback where we copy errors from model
    # to service so now in controller we can check and use only service's errors

    on_fail { errors! user.errors.to_h }
  end
end

# in controller

service = Users::Create.new(current_user, email: nil)
service.execute!

if service.success?
  # respond with ok
else
  # respond with unprocessable entity and service.errors
end

module Users
  class UpdateProfile < ApplicationService
    schema do
      optional(:first_name).filled(:str?)
      optional(:last_name).filled(:str?)
      optional(:login).filled(:str?)
      optional(:image)
      optional(:email).filled(format?: /\A[^ \n\r\s]+@[^ \n\r\s]+\z/i)
    end

    def execute!
      super { current_user.update(inputs) }
    end

    on_fail { errors!(current_user.errors) }
  end
end

module Users
  class Create
    def execute!
      # it will define accessors for all arguments:
      User.new(email: email, role: role, manager: current_user)
    end
  end
end

service = Users::Create.new(current_user, email: 'mail@google.com', role: 'employee')

module Users
  class Create
    schema do
      required(:email).filled(:str?)
      optional(:phone).filled(:str?)
    end

    def execute!
      # it will define accessors for `email` and `phone`, but won't define `role`
      User.new(email: email, phone: phone, manager: current_user) # phone is nil
    end
  end
end

service = Users::Create.new(current_user, email: 'mail@google.com', role: 'manager')