CONTROLLER They end up as lean HTTP endpoints. No business logic is to be found in the controller, they instantly delegate to their respective operation.

Oh, and did we say there won’t be controller tests anymore? That’s right. Only unit and integration tests.

class SongsController < ApplicationController
  def create
    run Song::Create do |ctx|
      redirect_to songs_path(ctx[:model])
    end
  end
end

MODEL Models contain associations, scopes and finders. Only persistence logic, no callbacks, no validations, no business logic here.

Instead, business code and callbacks are moved to operations.

class Song < ActiveRecord::Base
  has_many :albums
  belongs_to :composer
end

The OPERATION is the heart of the Trailblazer architecture. It orchestrates validations, policies, models, callback and business logic by leveraging a functional pipeline with built-in error handling.

Designed to be a stateless object, the operation passes around one mutable options hash and makes heavy use of Ruby keyword arguments - if you want it.

class Song::Create < Trailblazer::Operation
  step Model( Song, :new )
  step Policy::Pundit( Application::Policy, :create? )
  step Contract::Build( constant: Song::Contract::Create )
  step Contract::Validate()
  step Contract::Persist()
  fail Notifier::DBError
  pass :update_song_count!

  def update_song_count!(ctx, current_user:, **)
    current_user.increment_song_counter
  end
end

Any number of POLICYs can be used in an operation to grant or deny access to functionality.

Also, use your choice of authorization framework.

class Application::Policy < Pundit::Policy
  def create?
    user.can_create?(model)
  end
end

Validations are implemented with CONTRACT.

Trailblazer supports Reform and Dry::Schema validations in any number.

class Song::Contract::Create < Reform::Form
  property :title
  property :length

  validates :title, presence: true
end

And the best there’s only one way to run an operation. Any dependency, such as the current_user, must be injected from the outside.

The concept of global state does not exist in Trailblazer, which leads to simplified, mock-free testability and concurrent-ready code.

Song::Create.(
  { title: "Roxanne", length: 300 }, # params
  current_user: current_user         # dependencies
)

Clumsy, slow controller tests are history. Now that all your business logic is controlled by the operation, SIMPLE UNIT TESTS can test any edge-case scenario or avoid regressions.

Trailblazer’s encapsulation makes a programmer’s life better.

describe Song::Create do
  it "prohibits empty params" do
    result = Song::Create.({})

    expect(result).to be_failure
    expect(result[:model]).to be_new
  end
end