Using
repository pattern with Eloquent
for code that lasts

Who am I?

<?php

$me = [
    'name' => 'Damiano',
    'surname' => 'Petrungaro',
    'job' => 'Software Developer',
    'company' => [
        'name' => 'Car Match',
        'url' => 'https://carmatch.mx/'
    ],
    'github' => 'https://github.com/damianopetrungaro',
    'twitter' => '@damiano_dev',
    'buzzwords' => [
        'food', 'php', 'code', 'perfectionist', 'DDD', 'never stop learning'
    ]
];

Me(ow) at work

CATS ALERT!

Eloquent

The Eloquent ORM included with Laravel provides a beautiful, simple ActiveRecord implementation for working with your database.

- Laravel documentation

Active Record

An object that wraps a row

in a database table or view,

encapsulates the database access,

and adds domain logic on that data.

- Martin Fowler, PoEAA

Data Mapper, Table Data Gateway, Row Data Gateway

BUSINESS LOGIC

PERSISTENCE

USER

PRODUCT

CART

<?php

namespace App\Http\Controllers;

//...

class UserController extends Controller
{
    public function show(Request $request)
    {
        $name = $request->get('name', 'Damiano');

        return UserEloquent::where('name', $name)->first() ?: "No $name was found";
    }
}

How eloquent models are usually used

Read

<?php

namespace App\Http\Controllers;

class UserController extends Controller
{
    public function create(Request $request)
    {
        // Some validation logic here
        $user = new UserEloquent();
        $user->name = $request->name;
        // Some domain logic here
        $user->save();
        return $user
    }
}

How eloquent models are usually used

Write

Every time a breaking change is introduced in the model

SRP

A class should have only a single responsibility

Changes to only one part of the software's specification should be able to affect the specification of the class

Low flexibility & high coupling

One to one mapping between table structure and entity

One property of an Entity will be a column in a table or a field in a document

Our domain model depends on ORM behavior by design

Our model can't exist without the ORM and exposes behavior not needed by the domain

Repository pattern

to the rescue!

Repository pattern

Mediates between the domain
and data mapping layers
using a collection-like interface
for accessing domain objects.

- Edward Hieatt and Rob Mee, PoEAA

BUSINESS LOGIC

PERSISTENCE

USER
REPOSITORY

PRODUCT
REPOSITORY

CART
REPOSITORY

USER

PRODUCT

CART

<?php

namespace App\Repository;

// ...

class UserRepository
{
    public function __construct(UserEloquent $userModel)
    {
        $this->userModel = $userModel;
    }

    public function findByName(string $name):? UserEloquent
    {
        return $this->userModel->where('name', $name)->first();
    }
}

Free to use all the benefits of the
active record <3

<?php

namespace App\Http\Controllers;

//...

class UserController extends Controller
{
    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function show(Request $request)
    {
        $name = $request->get('name', 'Damiano');

        return $this->userRepository->findByName($name) ?: "No $name were found";
    }
}
<?php

namespace App\Http\Controllers;

class UserController extends Controller
{
    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function show(Request $request)
    {
        $name = $request->get('name', 'Damiano');

        if ($user = $this->userRepository->findByName($name)) {
            // We do not want this
            // $user->delete();
        }

        return $user ?: "No $name were found";
    }
}

Inject the dependecy where needed

...but

<?php

namespace App\Model;

interface User
{
    public function id(): int;

    public function name(): string;
}
<?php

namespace App\Model;

// ...

class UserEloquent extends Model implements User
{
    // ...
    public function id(): int
    {
        return $this->id;
    }

    public function name(): string
    {
        return $this->name;
    }
}

Use it with an interface

and encapsulate the active record feature only in the repositories

Imagine the repository as

an object that holds eloquent local query scope

<?php

namespace App\Model;

// ...

class UserEloquent extends Model implements User
{
    // ...

    public function scopeFindByName(string $name)
    {
        // ...
    }

    public function scopeBannedLastWeek()
    {
        // ...
    }
}
<?php

namespace App\Repository;

// ...

class UserRepository
{
    // ...

    public function findByName(string $name):? User
    {
        // ...
    }

    public function bannedLastWeek(): UserCollection
    {
        // ...
    }
}

How to 'write' using repositories?

<?php

namespace App\Repository;

// ...

class UserRepository
{
    // ...
    
    public function add(User $user): void
    {
        // ...
    }

    public function update(User $user): void
    {
        // ...
    }

    public function delete(int $id): void
    {
        // ...
    }

    // ...
}

Final tips

yes, it can be done better

<?php

namespace App\Repository;

use App\Model\User;

interface UserRepository
{
    public function findByName(string $name):? User;

    public function add(User $user): void;

    public function update(User $user): void;

    public function delete(int $id): void;
}
<?php

namespace App\Repository;

// ...

final class UserEloquentRepository implements UserRepository
{
    // ...

    public function findByName(string $name):? User
    {
        // ...
    }

    public function add(User $user): void
    {
        // ...
    }

    public function update(User $user): void
    {
        // ...
    }

    public function delete(int $id): void
    {
        // ...
    }
}

Use interface for repository too

will save you a lot of time when you need to migrate

<?php

namespace App\Model;

interface User
{
    public static fromName(string $name): self;
    // ...
}
<?php

namespace App\Model;

// ...

class UserEloquent implements User
{
    private function __construct()
    {
        // Ah! You can't use me!
    }

    public static function fromName(string $name): self
    {
        if(strlen($name) <= 5) {
            throw new InvalidNameException($name);
        }

        $user = new self;
        $user->name = $name;
        
        return $user;
    }
}

Build your entities always in a valid state

... with named constructor

<?php

namespace App\ValueObject;

final class Name
{
    // ...

    public function __construct(string $name)
    {
        // All validation rules here
        $this->name = $name;
    }
}
<?php

namespace App\Model;

// ...

class UserEloquent implements User
{

    // ...
    private function __construct()
    {
        // Ah! You can't use me!
    }

    public static function fromName(Name $name): self
    {
        
        $user = new self;
        $user->name = $name;
        
        return $user;
    }

    // ...
}

Build your entities always in a valid state

... using value objects

Repository easier to maintain

<?php

namespace App\Repository;

// ...

interface UserRepository
{
    public function findByEmail(Email $email):? User;

    public function findByName(Name $name):? User;

    public function getById(UserId $id): User;

    public function add(User $user): void;

    public function update(User $user): void;

    public function delete(UserId $id): void;
}
  • Isolate read and write operation
     
  • Domain model won't be anemic but rich
     
  • Maintain and migrate can't be easier
     
  • Isolate bugs focusing on domain model
     
  • Still using your preferred ORM under the hood
     
  • Easier to test

Recap

Questions?

Thank you!

twitter: @damiano_dev

slides: http://bit.ly/dp-eloquent

joind:  https://joind.in/talk/c94e6

Using Active Record

By Damiano Petrungaro

Loading comments...

More from Damiano Petrungaro