Introduction
Almost everyone in the rails community(and not only) talks about the slim controllers: "Let's move everything to the service objects and functions, keep controllers as simple as possible". It's a great concept, and I fully support it. Service objects and functions for controllers' methods(not only but mainly for them) usually have two additional parts besides business logic:
- input validation;
- errors passing.
They aren't a big problem if your function does not call other functions and does not have nested objects as the input arguments. The problem that they are love to grow and mysteriously interact with each other.
In this post, I want to share the way how you can overcome these problems. Grab yourself a cup of your favourite beverage ☕ and join this journey.
Time for experiments
Imagine that you are designing internal software for a laboratory. It should run experiments from the passed arguments. Arguments should be validated to get a sensible response instead of meaningless 500 errors.
Without dry libraries
➡️ Let's start from the controller for the experiment. The controller should only run the function and render results or errors:
class ExperimentsController
def create
result = ConductExperiment.call(experiment_params)
if result[:success]
render json: result[:result]
else
render json: result[:errors], status: :bad_request
end
end
private
def experiment_params
params.require(:experiment).permit(
:name,
:duration,
:power_consumption
)
end
end
➡️ Next, add the service object. It is a good practice to move the repeated part to the base object:
class ApplicationService
def initialize(*params, &block)
@params = params
@block = block
end
def call
validation_result = validate_params
if validation_result[:success]
execute
else
validation_result
end
end
def validate_params
{ success: true }
end
def self.call(*params, &block)
new(*params, &block).call
end
end
class ConductExperiment < ApplicationService
def initialize(params)
super
@params = params
end
def validate_params
errors = []
if @params[:duration].blank?
errors << 'Duration should be present'
return { success: false, errors: errors }
end
if @params[:duration] < 1
errors << 'Duration should be positive number'
return { success: false, errors: errors }
end
{ success: true }
end
def execute
if Random.rand > 0.3
{ success: true, result: 'Success!' }
else
{ success: false, errors: ['Definitely not success.'] }
end
end
end
It already looks cumbersome, don't ya?😕 But all of a sudden, users of our API requested to add the type validation to all fields and a new entity - research, that will accept an array of experiments and checks that summary power consumption is less than a defined limit. Sounds scary 😲. Doing this will be really hard with the current configuration, so let's add some dry libraries and look at how easy it will be.
The full version is here.
Update validations
➡️ First, we need to upgrade the validation process. For this will be used the gem dry-validation. It adds validations that are expressed through contract objects.
A contract specifies a schema with basic type checks and any additional rules that should be applied. Contract rules are applied only once the values they rely on have been successfully verified by the schema.
➡️ Begin by updating the ApplicationService. We replace validate_params method with validator, where can be defined either class name of the contract or contract itself. In the call, add the call of the validator and change the validation_result check, respectively.
class ApplicationService
def initialize(*params, &block)
@params = params
@block = block
end
def call
validation_result = validator.new.call(@params) unless validator.nil?
if validator.nil? || validation_result.success?
execute
else
{ success: false, errors: validation_result.errors.to_h }
end
end
def validator
nil
end
def self.call(*params, &block)
new(*params, &block).call
end
end
➡️ Next, add the class where will be defined validations. Contracts have two parts:
- schema(or params) where are defined basic type checks
- rules for complex checks which are applied after schema validations.
⚠️ Be careful with optional values. You should check that value is passed before the checking.
class ConductExperimentContract < Dry::Validation::Contract
schema do
required(:duration).value(:integer) # in seconds
optional(:title).value(:string)
optional(:power_consumption).value(:integer) # in MW
end
rule(:duration) do
key.failure('should be positive') unless value.positive?
end
rule(:power_consumption) do
key.failure('should be positive') if value && !value.positive?
end
end
➡️ In the ConductExperiment class, just replace the validation with the previously defined validator class.
class ConductExperiment < ApplicationService
def initialize(params)
super
@params = params
end
def validator
ConductExperimentContract
end
def execute
if Random.rand > 0.3
{ success: true, result: 'Success!' }
else
{ success: false, errors: ['Definitely not success.'] }
end
end
end
Looks great! Time to add functionality for the research process.
This class will be finished successfully if all experiments are finished successfully or will return an error message from the first failed experiment.
class ConductResearch < ApplicationService
def initialize(params)
super
@params = params
end
def validator
ConductResearchContract
end
def execute
result = []
@params[:experiments].each do |experiment_params|
experiment_result = ConductExperiment.call(experiment_params)
return experiment_result unless experiment_result[:success]
result << experiment_result[:result]
end
{ success: true, result: result }
end
end
➡️ The most interesting part is the ConductResearchContract. It validates each element of the experiments array for compliance with the schema defined in the ConductExperimentContract. Sadly, now, to run rules for each experiment, you must run them manually like in the rule(:experiments).
class ConductResearchContract < Dry::Validation::Contract
MAX_POWER_CONSUMPTION = 30
schema do
required(:title).value(:string)
required(:experiments).array(ConductExperimentContract.schema).value(min_size?: 1)
end
rule(:experiments).each do
result = ConductExperimentContract.new.call(value)
unless result.success?
meta_hash = { text: 'contain bad example' }.merge(result.errors.to_h)
key.failure(meta_hash)
end
end
rule do
total_power_consumption = values[:experiments].reduce(0) do |sum, experiment|
experiment[:power_consumption].nil? ? sum : sum + experiment[:power_consumption]
end
if total_power_consumption > MAX_POWER_CONSUMPTION
key(:experiments).failure("total energy consumption #{total_power_consumption} MW exceeded limit #{MAX_POWER_CONSUMPTION} MW")
end
end
end
✨ We did it! It validates everything and works great. But we can make it even better.
The result version of this example is here.
Make it simpler with monads
In this part I won't explain what are monads and how this library works, thats very good explained in the documentation and in thesecool posts: Functional Ruby with dry-monads, Improve Your Services Using Dry-rb Stack and Five common issues with services and dry-monads. Here I will just demonstrate how it can improve the existing code.
➡️ Firstly add dry-monads gem to the Gemset.
# ...
gem 'dry-monads'
# ...
➡️ After this add the add the behaviour of monads to contracts. For this, you should run the command Dry::Validation.load_extensions(:monads). For rails applications I usually create file config/initializers/dry.rb where store all global configs for dry gems.
➡️ Next update service objects. Replace these ifs with the do notation syntax.
class ApplicationService
include Dry::Monads[:result, :do]
def initialize(*params, &block)
@params = params
@block = block
end
def call
yield validator.new.call(@params) unless validator.nil?
execute
end
def validator
nil
end
def self.call(*params, &block)
new(*params, &block).call
end
end
➡️ In the ConductExperiment, wrap results to the Dry::Monads::Result monads
class ConductExperiment < ApplicationService
def initialize(params)
super
@params = params
end
def validator
ConductExperimentContract
end
def execute
if Random.rand > 0.3
Success('Success!')
else
Failure('Definitely not success.')
end
end
end
and replace that ugly construction with temporary variables with this neat form in the ConductResearch service.
class ConductResearch < ApplicationService
def initialize(params)
super
@params = params
end
def validator
ConductResearchContract
end
def execute
result =
@params[:experiments].map do |experiment_params|
yield ConductExperiment.call(experiment_params)
end
Success(result)
end
end
➡️ Because failure objects are different, result messages should also be handled differently.
class ExperimentsController < ApplicationController
def create
result = ConductExperiment.call(experiment_params.to_h)
if result.success?
render json: result.value!
else
error_object =
if result.failure.is_a?(Dry::Validation::Result)
result.failure.errors(full: true).to_h
else
result.failure
end
render(json: error_object, status: :bad_request)
end
end
private
def experiment_params
params.require(:experiment).permit(
:name,
:duration,
:power_consumption
)
end
end
That's all!🎆 Compare it with the previous version. I think you will agree - it looks more readable.
Result version is available here.
I hope this post was helpful for you. Have a nice day!
Top comments (0)