This is NOT a recommended way to work with Laravel. At the time of writing this, strong typing and static analysis tools were not available – with their wide usage now, there is no need to use hacks like this anymore.
In a few recent projects, we have experimented with a slight alteration of Eloquent Models and have found some great value. I thought to share this in case someone else benefits the same way we did 🚀
Let’s first bring a Product model to life for an imaginary e-commerce store:
php artisan make:model Product
We now have our brand new Product model under the App namespace:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Product extends Model
{
//
}
We do some initial setup at the beginning:
- Enforcing strict types
- Marking class as
final
- Adding logical code sections
…resulting in this:
<?php declare(strict_types=1);
namespace App;
use Illuminate\Database\Eloquent\Model;
final class Product extends Model
{
#-----------------------------------------------------------------
# Class Constants
#-----------------------------------------------------------------
//
#-----------------------------------------------------------------
# Class Properties
#-----------------------------------------------------------------
//
#-----------------------------------------------------------------
# Relationships
#-----------------------------------------------------------------
//
#-----------------------------------------------------------------
# Accessors and Mutators
#-----------------------------------------------------------------
//
}
Next, we adhere to some general team conventions regarding table and primary key name and include the necessary relations:
<?php declare(strict_types=1);
// ...
final class Product extends Model
{
// ...
#-----------------------------------------------------------------
# Properties
#-----------------------------------------------------------------
/**
* @var string
*/
protected $table = 'products';
/**
* @var string
*/
protected $primaryKey = 'product_id';
#-----------------------------------------------------------------
# Relationships
#-----------------------------------------------------------------
/**
* @return HasOne
*/
public function currency(): HasOne
{
return $this->hasOne(Currency::class, 'currencyCode', 'currency');
}
// ...
}
You may be wondering what’s new here, this is standard Laravel – you’re entirely correct. I’ve included these details to make sure someone new can also follow along 😌
At this stage, we introduce our own style accessors and mutators to the model (also known as getters/setters):
<?php declare(strict_types=1);
// ...
final class Product extends Model
{
// ...
#-----------------------------------------------------------------
# Accessors and Mutators
#-----------------------------------------------------------------
/**
* @return string
*/
public function getName(): string
{
return $this->getAttribute('name');
}
/**
* @param string $name
*/
public function setName(string $name): void
{
$this->setAttribute('name', $name);
}
/**
* @return float|null
*/
public function getPrice(): ?float
{
return $this->getAttribute('price');
}
/**
* @param float|null $value
*/
public function setPrice(?float $value): void
{
$this->setAttribute('price', $value);
}
/**
* @return bool
*/
public function isActive(): bool
{
return $this->getAttribute('is_active');
}
// ...
}
That’s pretty straightforward, but you may be wondering about the verbosity and why someone would write all these methods by hand.
What’s the benefit?
Well, we have seen these benefits since introducing this overall structure:
- Model is divided into logical sections, so easy to navigate
- Model properties are available through IDE auto-completion
- Model properties are type-hinted, thus using the power of strict type
- It still preserves the power of Eloquent, so no hacky overrides
In our team, we have seen an overall improvement in DX (developer experience) as a result of these small changes. There are fewer errors, code comprehension has improved and cognitive load has reduced while working with someone else’s code.
Why not just use public properties?
One question that comes up naturally when I present this to anyone: why not just use the public properties? Well, in my opinion, there are a few limitations:
- The data type of a given property cannot be enforced, you can set a float value to a property that is defined to store it in the DB
- The return type of a given property cannot be determined, so on a language level, you don’t know if a status field is supposed to return a string or int
- Property level data validation is difficult, you can set a negative value to a property that is clearly invalid (ex: negative price of a product)
- If a property column name is changed, that change needs to be done manually in all places where the property was accessed; as the properties are dynamic, thus cannot make use of IDE usage search
Closing Thoughts
You may want to give this a try and see if this benefits you in any way. This heavily favors the strong typing of PHP 7 so teams who has a preference towards that would get the most out of this. And lastly, your mileage may vary 🙂
Share your ideas and thoughts with me on Twitter!
