Parental Documentation

Parental allows you to extend a model to add specific behavior while referencing the same database table.

• Use the HasChildren trait on the parent model to allow it to act as a base for multiple child types and to enable automatic instantiation of child models when querying the parent.
• Use the HasParent trait on child models to tell Eloquent to use the parent's table instead of looking for a table named after the child class.

This solves the problem where Laravel normally expects a separate table for every model class.

// The "parent"
class User extends Model
{
    use HasChildren;
}

// The "child"
class Admin extends User
{
    use HasParent;

    public function impersonate($user) {
        //...
    }
}

// Returns "Admin" model, but references "users" table:
$admin = Admin::first();
$admin->impersonate($user);

To allow Laravel Nova resources to be shared between parent and child models, register the Parental\Providers\NovaResourceProvider in your NovaServiceProvider's boot method.

class NovaServiceProvider extends NovaApplicationServiceProvider
{
    public function boot() {
        parent::boot();
        // ...
        $this->app->register(\Parental\Providers\NovaResourceProvider::class);
    }
}

Install the Parental package via Composer to enable Single Table Inheritance (STI) in your Laravel Eloquent models.

composer require tightenco/parental

To use Parental, your parent table must have a column (defaulting to type) that stores the class name or an alias of the child model.

Customizing the type column

Set the $childColumn property on the parent model to use a different column name.

Using Type Aliases

To avoid storing full PHP class names in your database, use the $childTypes property on the parent model to map short aliases to class names. This decouples your database from your application structure.

Example Configuration

class User extends Model
{
    use HasChildren;

    protected $fillable = ['parental_type'];

    // Use a custom column name
    protected $childColumn = 'parental_type';

    // Use aliases instead of full class names
    protected $childTypes = [
        'admin' => Admin::class,
        'guest' => Guest::class,
    ];
}

You can transition a model from one child type to another using the become() method. This method returns a new instance of the target child model with the original attributes preserved.

Note: You must call save() on the returned instance to persist the change to the database.

You can listen for the transition using the becoming method on the target child class.

// Retrieve a pending order
$order = Order::first();

// Ship the order by transforming it
$order = $order->become(ShippedOrder::class);

// Updates the "type" column to "shipped" and returns a ShippedOrder instance
$order->save();

// Listen for the transition
ShippedOrder::becoming(function ($shippedOrder) {
    // Do something before the model is saved...
});

The loadChildren macro allows you to eager load specific relationships on a collection of models that may contain different child classes (Single Table Inheritance). It accepts a map where keys are the class names of the models and values are arrays of relationship names to load for that specific class.

Example usage:

$collection->loadChildren([
    ChildClassA::class => ['relationA'],
    ChildClassB::class => ['relationB'],
]);

The loadChildrenCount macro allows you to eager load the counts of specific relationships on a collection of models that may contain different child classes. It accepts a map where keys are the class names of the models and values are arrays of relationship names to count for that specific class.

Example usage:

$collection->loadChildrenCount([
    ChildClassA::class => ['relationA'],
    ChildClassB::class => ['relationB'],
]);