CODEWITHSUNDEEP
phplaraveleloquent
André Teixeira
André Teixeira

Reputation: 2562

Laravel extend Eloquent and 3rd party class

I'm currently working on my first PHP/Laravel 4 project, I'm developing on it a storage class to add Eloquent support to a 3rd party library.

My EloquentStorage class extends the AbstractStorage class from the library, and I make usage of most of AbstractStorage methods. Now that I want to add Eloquent support to my new EloquentStorage class, I faced the fact that PHP does not support multiple inheritance.

Is there a proper way to define an Eloquent model without extending it as:

class MyClass extends Eloquent {}

And, if not, how to deal with such situation when I need to extend 3rd party class and also extend Eloquent? Maybe using Laravel's IoC?

Upvotes: 2

Views: 883

Answers (1)

Jeff Lambert
Jeff Lambert

Reputation: 24661

I think your model should extend from Eloquent, and instead be accessed through a repository. Your repository can have a $storage property, and would be responsible for calling the appropriate methods on your AbstractStorage implementation. Below is more pseudo- than actual code, but illustrates where you can plug in your implementation for an update operation.

class MyClass extends Eloquent 
{
    /* Normal Eloquent model implementation */
}

class MyRepository
{
    protected $storage;
    protected $myClass;

    public function __construct(MyClass $myClass, AbstractStorage $storage)
    {
        $this->myClass = $myClass;
        $this->storage = $storage;
    }

    public function update($id, $data)
    {
        // This is just an example operation, basically here's your chance to call 
        // the 3rd-party implementation. Here is pre-eloquent update, but can be 
        // after
        $this->storage->update($id, $data);

        // Use the empty Eloquent class property instance to obtain an instance of 
        // the requested model
        $instance = $this->myClass->find($id);
        // set instance properties
        $instance->save();

        // Example post-eloquent update
        $this->storage->update($id, $data);
    }
}

class MyStorage extends AbstractStorage { /* Your Storage Implementation */ }

$repo = new MyRepository(new MyClass, new MyStorage);
// Update item id 42's foo property
$repo->update(42, [ 'foo' => 'bar' ]);

A benefit to this approach is that the construction of the repository itself can be offloaded to the IoC through a Service Provider, and be injected inside of a controller / form validator etc, which means the execution will become automatic and hide the underlying complexity of the 3rd party library from the rest of the system (the repository helps keep your 3rd party abstraction from leaking).

Another benefit is that you don't need any special code in your eloquent models having anything to do with your completely unrelated 3rd party code. All of the logic is encapsulated in a single spot, and can even be shared amongst multiple models. Want to change 3rd party providers? Write a new implementation of AbstractStorage, update the service provider and you're done.

One other benefit is improved testability. Instead of statically utilizing an eloquent model directly (a la $user = User::find($id)) you would be manipulating your repository object instead ($user = $this->repo->find($id)). Since your repository can be trivially mocked and itself be tested (without also testing Eloquent or hitting the database), you can write integration tests on all of your controller routes and know the moment that changes to your codebase break your business rules.

Upvotes: 1

Related Questions