Moving to repositiories

Moving to repositories
no golden hammer

Arturs Meisters
Developer at Funding Circle

class LoanSignupController < ApplicationController
def create
loan = Loan.create(params[:loan])
if loan.persisted?
redirect_to loan_path(loan.id)
else
render :new
end
end
end
class Loan < ActiveRecord::Base
validate :amount, :title, persistence: true
end

class Loan < ActiveRecord::Base
belong_to :borrower
has_many :loan_parts
has_many :loan_part_distributions, through: :loan_parts
has_many :investors
has_many :repayments
validates :amount, :title, :description, presence: true
validates :amount,
numericality: {
greater_than: 1000,
less_than: 100_000
}
end

...that’s without any methods

fields in DB that shouldn't be exposed

def show
loan = Loan.find(params[:id])
render :json
end

def show
loan = LoanPresenter.new(Loan.find(params[:id]))
render loan.to_json
end
class LoanPresenter
def initialize(loan)
@loan = loan
end
def to_json
{
id: @loan.id,
amount: @loan.amount.to_money,
title: @loan.title
}
end
end

● attr_accessible
● strong parameters

user experience that doesn't map to DB
schema directly

def create
user = User.new(params[:user])
if user.valid?
user.save!
redirect_to :user_profile(user)
else
render :new
end
end

def create
user = User.create_with_profile_and_sequrity_questions(params[:user])
# and so on...
end
def create_with_profile_and_sequrity_questions(params)
profile = Profile.new(
first_name: first_name[:first_name],
last_name: params[:last_name]
)
user_params = params.reject{|k,_|
[:first_name, :last_name].include?(k)
}
create(user_params.merge(profile: profile))
end

lengthy life cycle with many different states

validates :amount, :title, presence: true, if: "active?"
validates :closed_at, presence: true if: "closed?"
validates :recovered_amount, if: "defaulted?"
before :assign_goverment_bid if: "fully_funded?"

“An object that wraps a row in database table
or view, encapsulates database access, and
adds domain logic on that data.”
Martin Fowler
Patterns of Enterprise Application Architecture (2003)

An object that wraps a row in database table
or view, encapsulates database access, and
adds domain logic on that data.
Martin Fowler

Our ActiveRecord models had a lot of domain
logic in them

… and almost every change in persistence layer
caused problems within domain layer and vice
versa

It is fast and easy to start with ActiveRecord,
but it may not be enough

Goals
● process driven application
● manageable chunks of code
● moving in small steps

API dictates how and what data needs to be
returned

class LoanEndpoint
#... skipped code
get "/investor/:id/loans" do
loans = LoanRepository.new.all_for_investor(params[:id])
render(loans)
end
end

separate domain logic from data access layer

class LoanRepository
def all_for_investor(investor_id)
loans = Loan.join(:investor)
.where(investor_id: investor)
loans.map{|loan| map_to_entity(loan) }
end
#... skipped code
end

#... skipped code
private
def map_to_entity(record)
Entities::Loan.new.tap do |loan|
loan.id = record.id
loan.title = record.title
loan.amount_cents = (record.amount * 100).to_i
end
end
end

#... skipped code
private
mapper.map(record)
end
def mapper
@mapper ||= Loan::Mapper.new
end
end

class LoanEntity
attribute :id
attribute :status
attribute :owner_id
attribute :loan_parts
def principal_remaining
if status != "paid"
loan_parts.inject(0){|sum, loan_part|
sum + loan_part.principal_remaining
}
else
0
end
end
end

class LoanValidator < ActiveModel::Validator
MINIMUM_LOAN_AMOUNT = 5_000
def validate(loan_entity)
unless loan.amount >= MINIMUM_LOAN_AMOUNT
loan.errors.add(
:amount,
"must be greater or equal to #{MINIMUM_LOAN_AMOUNT}"
)
end
end
end

resource’s properties are combined from
different sources

loans = Loan
.join(:investor)
.preload(:borrower)
.where(investor_id: investor_id)
loans.map{|loan| map_to_entity(loan) }
end
#... skipped code
end

#... skipped code
private
loan.id = record.id
loan.title = record.title
loan.amount_cents = (record.amount * 100).to_i
loan.borrower = Entities::Borrower.new.tap do |borrower|
borrower.id = record.borrower.id
borrower.name = record.borrower.full_name
end
end
end
end

external service as data source

loans = LoanService.fetch_for_investor(investor_id)
.and_then do |records|
borrower_ids = records.map{|record| record[:borrower_id] }
borrowers = Borrower.find(borrower_ids)
records.map do |record|
map_loan(record, borrowers)
end
end
end
#...skipped code
end

#...skipped code
private
def map_loan(loan, borrower)
loan.id = record[:id]
loan.title = record[:title]
loan.amount_cents = record[:amount_cents]
loan.borrower = map_loan_borrower(loan, borrowers)
end
end
def map_loan_borrower(loan, borrowers)
borrower = borrowers.detect{|borrower| loan.borrower_id = borrower.id }
Entities::Borrower.new.tap do |borrower|
borrower.id = record.borrower.id
borrower.name = record.borrower.full_name
end
end
end

more focus on business processes than
resources

class LoanAcceptanceService
def call
end
end
class LoanDefaultingService
def call
end
end
class UserSignUpService
def call
end
end

class SellLenderLoanPart
def initialize(lender_source = nil, loan_part_source = nil)
@lender_source = lender_source || LenderRepository.new
@loan_part_source = loan_part_source || LoanPartRepository.new
end
def call(buyer_id, loan_part_id)
buyer = @lender_source.find(buyer_id)
loan_part = @loan_part_source.find(loan_part_id)
seller_loan_part = loan_part.snapshot
@loan_part_source.create(seller_loan_part.sell)
loan_part.change_ownership_to(buyer)
@loan_part_source.update(loan_part)
end
end

Problems and challenges
● more application layers
● a little less flexibility in how you access data
● mind-shift to work with in-memory objects
● responsibilities of entities
● validations

Repository mediates between the domain and
data mapping layers using a collection-like
interface for accessing domain objects
Martin Fowler

Summary
● Now we are able to move in small steps
● Abstract away from data sources
● Process driven applications
but…
● I would never start with repositories

Questions?
https://github.com/kalifs

Moving to repositiories

More Related Content

Similar to Moving to repositiories

Recently uploaded

Moving to repositiories

Editor's Notes