Hello. I have this situation:

One category can have subcategories(they use the same model. The difference is that a subcategory have the ID of it's father, while the father category have the field 'FatherID' as NULL), and both can have posts on them. Something like this:

Category Father posts Subcategory Subcategory Posts

When I delete a father category, I need to softdelete it's posts, it's subcategories and their posts. However, I'm not being able to softdelete the subcategories posts. Can you help me with this ?

Thanks in advance. This package is awesome =).

the package works perfect for one-to-many relationship, but when it comes to many-to-many relationship it's not working here is my code :

    class Product extends Model
    {
        use HasFactory, SoftDeletes,CascadeSoftDeletes;
        protected $table = 'products';
        protected $cascadeDeletes  = ['product_categories_2'];
    
        public function product_categories_2(){
            return $this->belongsToMany(Category::class,'product_filter_categories')->using(ProductFilterCategory::class);
        }
    }

is it a wrong in my code or this package don't support many-to-many relation ?

<?php

declare(strict_types=1);

namespace App\Traits;

// https://github.com/michaeldyrynda/laravel-cascade-soft-deletes

use App\Exceptions\CascadeSoftDeleteException;
use Illuminate\Database\Eloquent\Relations\Relation;

trait CascadeSoftDeletes
{
    /**
     * Boot the trait.
     *
     * Listen for the deleting event of a soft deleting model, and run
     * the delete operation for any configured relationship methods.
     *
     * @throws \LogicException
     */
    protected static function bootCascadeSoftDeletes()
    {
        static::deleting(function ($model) {
            /** @var CascadeSoftDeletes $model */
            $model->validateCascadingSoftDelete();

            $model->runCascadingDeletes();
        });
        static::restoring(function ($model) {
            /** @var CascadeSoftDeletes $model */
            $model->validateCascadingRestore();

            $model->runCascadingRestores();
        });
    }

    /**
     * Validate that the calling model is correctly setup for cascading soft deletes.
     *
     * @throws \App\Exceptions\CascadeSoftDeleteException
     */
    protected function validateCascadingSoftDelete()
    {
        if (! $this->implementsSoftDeletes()) {
            throw CascadeSoftDeleteException::softDeleteNotImplemented(get_called_class());
        }

        if ($invalidCascadingDeletesRelationships = $this->hasInvalidCascadingDeletesRelationships()) {
            throw CascadeSoftDeleteException::invalidRelationships($invalidCascadingDeletesRelationships);
        }
    }

    /**
     * Validate that the calling model is correctly setup for cascading restores.
     *
     * @throws \App\Exceptions\CascadeSoftDeleteException
     */
    protected function validateCascadingRestore()
    {
        if (! $this->implementsSoftDeletes()) {
            throw CascadeSoftDeleteException::softDeleteNotImplemented(get_called_class());
        }

        if ($invalidCascadingRestoresRelationships = $this->hasInvalidCascadingRestoresRelationships()) {
            throw CascadeSoftDeleteException::invalidRelationships($invalidCascadingRestoresRelationships);
        }
    }

    /**
     * Run the cascading soft delete for this model.
     *
     * @return void
     */
    protected function runCascadingDeletes()
    {
        foreach ($this->getActiveCascadingDeletes() as $relationship) {
            $this->cascadeSoftDeletes($relationship);
        }
    }

    /**
     * Run the cascading restore for this model.
     *
     * @return void
     */
    protected function runCascadingRestores()
    {
        foreach ($this->getActiveCascadingRestores() as $relationship) {
            $this->cascadeRestores($relationship);
        }
    }

    /**
     * Cascade delete the given relationship on the given mode.
     *
     * @param  string  $relationship
     * @return void
     */
    protected function cascadeSoftDeletes($relationship)
    {
        $delete = $this->forceDeleting ? 'forceDelete' : 'delete';

        foreach ($this->{$relationship}()->get() as $model) {
            $model->pivot ? $model->pivot->{$delete}() : $model->{$delete}();
        }
    }

    /**
     * Cascade restore the given relationship.
     *
     * @param  string  $relationship
     * @return void
     */
    protected function cascadeRestores($relationship)
    {
        foreach ($this->{$relationship}()->onlyTrashed()->get() as $model) {
            /** @var \Illuminate\Database\Eloquent\SoftDeletes $model */
            $model->pivot ? $model->pivot->restore() : $model->restore();
        }
    }

    /**
     * Determine if the current model implements soft deletes.
     *
     * @return bool
     */
    protected function implementsSoftDeletes()
    {
        return method_exists($this, 'runSoftDelete');
    }

    /**
     * Determine if the current model has any invalid cascading deletes relationships defined.
     *
     * A relationship is considered invalid when the method does not exist, or the relationship
     * method does not return an instance of Illuminate\Database\Eloquent\Relations\Relation.
     *
     * @return array
     */
    protected function hasInvalidCascadingDeletesRelationships()
    {
        return array_filter($this->getCascadingDeletes(), function ($relationship) {
            return ! method_exists($this, $relationship) || ! $this->{$relationship}() instanceof Relation;
        });
    }

    /**
     * Determine if the current model has any invalid cascading restores relationships defined.
     *
     * A relationship is considered invalid when the method does not exist, or the relationship
     * method does not return an instance of Illuminate\Database\Eloquent\Relations\Relation.
     *
     * @return array
     */
    protected function hasInvalidCascadingRestoresRelationships()
    {
        return array_filter($this->getCascadingRestores(), function ($relationship) {
            return ! method_exists($this, $relationship) || ! $this->{$relationship}() instanceof Relation;
        });
    }

    /**
     * Fetch the defined cascading soft deletes for this model.
     *
     * @return array
     */
    protected function getCascadingDeletes()
    {
        return isset($this->cascadeDeletes) ? (array) $this->cascadeDeletes : [];
    }

    /**
     * Fetch the defined cascading restores for this model.
     *
     * @return array
     */
    protected function getCascadingRestores()
    {
        return isset($this->cascadeRestores) ? (array) $this->cascadeRestores : [];
    }

    /**
     * For the cascading deletes defined on the model, return only those that are not null.
     *
     * @return array
     */
    protected function getActiveCascadingDeletes()
    {
        return array_filter($this->getCascadingDeletes(), function ($relationship) {
            return ! is_null($this->{$relationship});
        });
    }

    /**
     * For the cascading restores defined on the model, return only those that are not null.
     *
     * @return array
     */
    protected function getActiveCascadingRestores()
    {
        return array_filter($this->getCascadingRestores(), function ($relationship) {
            return ! is_null($this->{$relationship}()->onlyTrashed());
        });
    }
}

Hi! (me again :3)

here: https://github.com/michaeldyrynda/laravel-cascade-soft-deletes/blob/master/src/CascadeSoftDeletes.php#L22L27

You restrict usage to models implementing soft delete.

In my case I hard delete records but I want to use your trait to trigger deleting events on children models

thanks

I'm receiving the following error when deleting a model using this trait.

FatalThrowableError in CascadeSoftDeletes.php line 40: Call to a member function delete() on null

Full stack trace:

in CascadeSoftDeletes.php line 40
at Post::Iatstuti\Database\Support\{closure}(object(Post))
at call_user_func_array(object(Closure), array(object(Post))) in Dispatcher.php line 221
at Dispatcher->fire('eloquent.deleting: App\Post', array(object(Post)), true) in Dispatcher.php line 164
at Dispatcher->until('eloquent.deleting: App\Post', object(Post)) in Model.php line 1686
at Model->fireModelEvent('eloquent.deleting: App\Post') in Model.php line 1122
at Model->delete() in PostsController.php line 142

The $child variable here in the trait is returning null.

$delete = $model->forceDeleting ? 'forceDelete' : 'delete';

            foreach ($model->getCascadingDeletes() as $relationship) {
                foreach ($model->{$relationship} as $child) {
                    $child->{$delete}();
                }
            }

I must be missing something obvious because testing it like so, it appears that $child is not being set when the for loop runs.

dd($model->getCascadingDeletes()); // returns ['website'] (the model relationship to be deleted)

 foreach ($model->getCascadingDeletes() as $relationship) {
                foreach ($model->{$relationship} as $child) {
                    dd($child); // returns Null
                    dd($model->{$relationship}); // returns the cascading model to be deleted. 
                    $child->{$delete}();
                }
            }

If anyone can point me in the right direction what I or this package is doing wrong, that would be much appreciated :)

Hi Michael,

I have found an issue where package couldn't handle situation, when you want to perform an actual DELETE statement to your model.

That's because you want to delete record that is associated with records from other tables with foreign keys so you get a SQL error like this:

SQLSTATE[23000]: Integrity constraint violation: 1451 Cannot delete or update a parent row: a foreign key constraint fails (`dbname`.`comments`, CONSTRAINT `comments_review_id_foreign` FOREIGN KEY (`review_id`) REFERENCES `reviews` (`id`)) (SQL: delete from `reviews` where `id` = 1)

This little change handle makes this possible now.

I have model which uses soft delete but the action for onDelete is restrict instead of cascade. I have gonna through your code and you haven't handling this case.

Can you be able to provide any solution to check the type of onDelete action if the type restrict then do not delete and show error?

Hi

I am using laravel 7.3 when i run this command 'composer require dyrynda/laravel-cascade-soft-deletes'

I have get this error : Problem 1 - Root composer.json requires dyrynda/laravel-cascade-soft-deletes ^4.0 -> satisfiable by dyrynda/laravel-cascade-soft-deletes[4.0.0]. - dyrynda/laravel-cascade-soft-deletes 4.0.0 requires illuminate/database ^8.0 -> found illuminate/database[v8.0.0, ..., v8.13.0] but it conflicts with another require.

I am unable to found root casue can you please check this.

First your package is great. works perfect. The issue that I am having is that I have my own event listeners for a model for 'deleting' your trait is firing before my deleting listener, I was wondering if you knew of a way to have it so my local model listener fired before your trait deleting listener.

Just to give you an example. I have a Model called Runs which has many Runners attached to it. I have an event setup for when a Run gets deleted to send a notification to all Runners that the run was deleted. Since your trait is cascading down to runners first, when i go to grab a collection of runners $run->runners()->get(); It returns 0 because they were already soft deleted.

Hi Actually Its not properly working for me. I have the following two models: Menu SubMenu

-->I also added the code on the model but its doesn't works. `class Menu extends Model { use HasFactory; use SoftDeletes; use CascadeSoftDeletes;

protected $cascadeDeletes = ['subMenusFromMenu'];
protected $dates = ['deleted_at'];


public function subMenusFromMenu(): HasMany
{
    return $this->hasMany(SubMenu::class, 'menu_id', 'id');
}

}`

I tried to delete Menu , But after deleting menu the related child submenu records doesn't delete.

I installed the package successfully with one->many relationship child. Cant seem to get it going with a polymorphic setup. Is it supported?

PS. Good work on the Laravel News podcast. It's great to hear a familiar accent in the Laravel world.

Hello, thanks for sharing your knowledge. I installed the code via composer and the system is showing the message: Undefined type 'Dyrynda\Database\Support\CascadeSoftDeletes' . Can you help me?