separating an Eloquent Model from business logic - php

Question

I want to write discrete framework agnostic models.
I wrote interfaces for all of these models.
The problem is when implementing these interfaces, for example with Eloquent I'm linking all my business logic into the ORM.
For example I want a method addVariation on a Product model.
The Interface
interface ProductInterface
{
/**
* Adds a variation
*
* #param VariationInterface $variation
*/
public function addVariation(VariationInterface $variation);
// ...
}
The Concretion
class Product extends Model
{
/**
* #param Collection | VariationInterface
*/
protected $variations;
public function addVariation(VarientInterface $varient)
{
if( ! $this->hasVariation($varient) )
{
$this->variations->add($variations);
}
return $this;
}
}
The problem I have is all my business logic lives in my specific Eloquent ORM implementation of my model.
How could I possibly separate this out? The only real dependancy I can see is I need a collection class of some type? or maybe I can just use plain old arrays?
I just dont want to link all my logic into a specific ORM I want to remain framework agnostic.

Answer 1

Just remove all your logic from the Eloquent ORM.
You only need an ORM to make saving and retrieving data from a database easier. You should write all your business logic with plain old php objects. You can then create some general PersistenceGateway interface that all your business logic models use e.g.
interface PersistenceGatway {
public function saveGatewayData($id, array $data);
public function retrieveGatewayData($id)
}
Your decoupled business logic uses this interface to save and retrieve data. Then all you need to do is implement the interface with your ORM of choice (or you may need to also create some adaptor class to help you). You can now plugin any ORM you like, so long as it implements the PersistenceGateway interface.
Take a look at Uncle Bobs Clean Architecture. Web frameworks like Laravel should be a plugin to your app/business logic, not the other way around.
Edit: Very basic example.
class SomeBusinessLogic {
// Note: Class depends on the PersistenceGateway. Any class
// that implements this interface can be passed in. This is
// essentially how you decouple logic from ORMS. You can now
// implement this interface with any ORM you like and pass it in
public __construct(PersistenceGateway $gateway){
$this->gateway = $gateway;
}
public function someLogicMethod($id){
// do something and save state to the gateway
$this->gateway->saveGatewayData($id, ['some_state'=>'value']);
}
public function someDataReturnMethod($id){
return $this->gateway->retrieveGatewayData($id);
}
}
// Im extending from Eloquent here, but you can do a similar thing
// with any ORM.
class SomeEloquentModel extends Eloquent implements PersistenceGateway {
public function saveGatewayData($id, array $data){
$model = $this->find($id);
// call eloquent save method
$model->save($data);
}
public function retrieveGatewayData($id){
// retrieve the data. Important to return
// an array NOT an eloquent model, otherwise
// we are still coupled. I think toArray() is
// the correct method to call on eloquent model
return $this->find($id)->toArray();
}
}
class SomeController {
class someControllerMethod {
// Your controller decides on the implementation of PersistenGateway
// to use. You could also use an IoC container which would be a slightly
// cleaner solution
$logic = new SomeBusinessLogic(new SomeEloquentModel());
$logic->someLogicMethod(Input::get('id'));
return $logic->someDataReturnMethod(Input::get('id'));
}
}