Extending a model erases relations instead of merging them

[tschallacka]

When you have a model

use Winter\Storm\Database\Model;

class Foo implements Model {
   public $table = 'foo';
   public $belongsTo = ['bar' => Bar::class];
}

class Baz extends Foo {
   public $belongsTo = ['bal' => Bal::class];
}

if you do a new Baz() it will have only one property in the $belongsTo and that is ['baz' => Ball']

I would like it when there would be a trait or something that makes a model inherit the relationships of the "parent" classes when so chosen.

By using class_parents($this); you can get a list of the parents and array_merge the values into the currents classes relationship array definitions.

I could write a behaviour for this, but would such a feature be welcome and what should it be named?

All I can think of is $implement = [JustLikeParent::class] but that's a silly name.

[mjauvin]

Just merge the parent's relation property in the constructor instead.

[tschallacka]

Mhh, could do that too. Add it to the base class, but a behaviour would be cool for that too imho.

So one doesnt need to repeat it everytime one find itself needing this feature in unrelated models.

Like I said, I can write the behavior, I only have trouble coming up with a good apropriate name, and wether this would be a useful addition to thestorm core.

[mjauvin]

Something like:

    public function __construct()
    {   
        parent::__construct();
        $this->$belongsTo = array_merge($this->belongsTo, ['bal' => Bal::class]);
    }

[LukeTowers]

Why are you extending that many classes? What's the use case? That will help us understand this request further.

[tschallacka]

Well, I'm busy developing a magento eloquent compatibility module.
Magento has a overcomplicated relational database, which makes it possible to add more than 2048 properties to a model.
Each type(datetime, varchar, int, etc...) has its own table.
There are roughly five times such table sets for properties, so 25.
All those 25 tables, except for the table name and belongsTo target are the same, thereare 5 seperate possible belongsTo targets(Product, quote, order, etc...)

Ideally I'd make a base AttributeValue model that is the attribute value holder, which has some scopes and attributename(seperate table that contains name of property) belongsTo

Then id like a base PropertyValue model extending the base AttributeValue model, adding a belongsTo for Product for example, plus a scope to filter the attributesnames by attribute type product.

Then I'd like to extend the base PropertyValue 5 times for the different tables that can hold values.

That becomes easier with inheritance of relation properties.

I was thinking a behaviour that does like(but more optimized than this, im on mobile)

public function __construct($parent)
{
  $ancestors = class_parents($parent);
  foreach($ancestors as $ancestor) {
  $ancestor = new $ancestor();
  if(property_exists('belongsTo', $ancestor)
    $parent->belongsTo =  array_merge($parent->belongsTo, $ ancestor-> belongsTo);
  //repeat for other relations
  }
}

This way you could implement this behaviour in a base class and it would cascade down nicely without having to copy paste stuff for relations defined in parents.

[LukeTowers]

Hmm, sounds like you'd be best served by building your own base Model class extending the Winter one and using that as the base for all your other models. I'm not sure that the use case is common enough to be worth including in the core at this point tbh.

[tschallacka]

You're probably right.
I'll make it a plugin though, should someone need a similar feature.

[LukeTowers]

The magento connection as a whole would be a good plugin, I did something similar for ExpressionEngine. The base model class would probably be best to just post in an answer here and mark it as the accepted answer for people to find via google

[mjauvin]

I was going to suggest exactly that @LukeTowers

[tschallacka]

I ended up writing my own little utility library, that can be used by anyone that wishes to transport relationships defined in the parents to the current instance, by adding one class to the $implement array.

https://github.com/tschallacka/storm-inherit-relations

composer require tschallacka/storm-inherit-relations ^1.0

Usage

In a model in which you wish to glean the relationships defined in
the parents add this to your $implements array:

public $implement = [\Tschallacka\StormInheritRelations\Behavior\InheritRelations];

Model example:

<?php
namespace Tschallacka\Example\Attribute;

use Winter\Storm\Database\Model;
use Tschallacka\StormInheritRelations\Behavior\InheritRelations;

class AttributeValue extends Model
{
    public $primaryKey = 'value_id';

    public $implement = [
        InheritRelations::class
    ];

    public $belongsTo = [
        'attribute' => AttributeName::class,
    ];
}