Improve automatic detaching / deletion of relations

src/Auth/Models/User.php

@@ -39,7 +39,7 @@ class User extends Model implements \Illuminate\Contracts\Auth\Authenticatable
      * @var array Relations
      */
     public $belongsToMany = [
-        'groups' => [Group::class, 'table' => 'users_groups']
+        'groups' => [Group::class, 'table' => 'users_groups'],
     ];
 
     public $belongsTo = [
@@ -154,17 +154,6 @@ public function afterLogin()
         $this->forceSave();
     }
 
-    /**
-     * Delete the user groups
-     * @return void
-     */
-    public function afterDelete()
-    {
-        if ($this->hasRelation('groups')) {
-            $this->groups()->detach();
-        }
-    }
-
     //
     // Persistence (used by Cookies and Sessions)
     //

src/Database/Model.php

@@ -998,6 +998,7 @@ protected function performDeleteOnModel()
 
     /**
      * Locates relations with delete flag and cascades the delete event.
+     * For pivot relations, detach the pivot record unless the detach flag is false.
      * @return void
      */
     protected function performDeleteOnRelations()
@@ -1008,32 +1009,31 @@ protected function performDeleteOnRelations()
              * Hard 'delete' definition
              */
             foreach ($relations as $name => $options) {
-                if (!Arr::get($options, 'delete', false)) {
-                    continue;
-                }
-
                 if (!$relation = $this->{$name}) {
                     continue;
                 }
 
-                if ($relation instanceof EloquentModel) {
-                    $relation->forceDelete();
-                }
-                elseif ($relation instanceof CollectionBase) {
-                    $relation->each(function ($model) {
-                        $model->forceDelete();
-                    });
-                }
-            }
-
-            /*
-             * Belongs-To-Many should clean up after itself always
-             */
-            if ($type == 'belongsToMany') {
-                foreach ($relations as $name => $options) {
+                if (in_array($type, ['belongsToMany', 'morphToMany', 'morphedByMany'])) {
+                    // we want to remove the pivot record, not the actual relation record
                     if (Arr::get($options, 'detach', true)) {
                         $this->{$name}()->detach();
                     }
+                } else if (in_array($type, ['belongsTo', 'hasOneThrough', 'hasManyThrough', 'morphTo'])) {
+                    // the model does not own the related record, we should not remove it.
+                    continue;
+                } else {
+                    // attachOne, attachMany, hasOne, hasMany, morphOne, morphMany
+                    if (!Arr::get($options, 'delete', false)) {
+                        continue;
+                    }
+
+                    if ($relation instanceof EloquentModel) {
+                        $relation->forceDelete();
+                    } elseif ($relation instanceof CollectionBase) {
+                        $relation->each(function ($model) {
+                            $model->forceDelete();
+                        });
+                    }
                 }
             }
         }

src/Database/Traits/SoftDelete.php

@@ -115,21 +115,24 @@ protected function performSoftDeleteOnRelations()
         $definitions = $this->getRelationDefinitions();
         foreach ($definitions as $type => $relations) {
             foreach ($relations as $name => $options) {
-                if (!array_get($options, 'softDelete', false)) {
-                    continue;
-                }
-
                 if (!$relation = $this->{$name}) {
                     continue;
                 }
-
-                if ($relation instanceof EloquentModel) {
-                    $relation->delete();
+                if (!array_get($options, 'softDelete', false)) {
+                    continue;
                 }
-                elseif ($relation instanceof CollectionBase) {
-                    $relation->each(function ($model) {
-                        $model->delete();
-                    });
+                if (in_array($type, ['belongsToMany', 'morphToMany', 'morphedByMany'])) {
+                    // relations using pivot table
+                    $value = $this->fromDateTime($this->freshTimestamp());
+                    $this->updatePivotDeletedAtColumn($name, $options, $value);
+                } else {
+                    if ($relation instanceof EloquentModel) {
+                        $relation->delete();
+                    } elseif ($relation instanceof CollectionBase) {
+                        $relation->each(function ($model) {
+                            $model->delete();
+                        });
+                    }
                 }
             }
         }
@@ -177,6 +180,19 @@ public function restore()
         return $result;
     }
 
+    /**
+     * Update relation pivot table deleted_at column
+     */
+    protected function updatePivotDeletedAtColumn(string $relationName, array $options, string|null $value)
+    {
+        // get deletedAtColumn from the relation options, otherwise use default
+        $deletedAtColumn = array_get($options, 'deletedAtColumn', 'deleted_at');
+
+        $this->{$relationName}()->newPivotQuery()->update([
+            $deletedAtColumn => $value,
+        ]);
+    }
+
     /**
      * Locates relations with softDelete flag and cascades the restore event.
      *
@@ -191,18 +207,22 @@ protected function performRestoreOnRelations()
                     continue;
                 }
 
-                $relation = $this->{$name}()->onlyTrashed()->getResults();
-                if (!$relation) {
-                    continue;
-                }
-
-                if ($relation instanceof EloquentModel) {
-                    $relation->restore();
-                }
-                elseif ($relation instanceof CollectionBase) {
-                    $relation->each(function ($model) {
-                        $model->restore();
-                    });
+                if (in_array($type, ['belongsToMany', 'morphToMany', 'morphedByMany'])) {
+                    // relations using pivot table
+                    $this->updatePivotDeletedAtColumn($name, $options, null);
+                } else {
+                    $relation = $this->{$name}()->onlyTrashed()->getResults();
+                    if (!$relation) {
+                        continue;
+                    }
+
+                    if ($relation instanceof EloquentModel) {
+                        $relation->restore();
+                    } elseif ($relation instanceof CollectionBase) {
+                        $relation->each(function ($model) {
+                            $model->restore();
+                        });
+                    }
                 }
             }
         }

tests/Database/Traits/SoftDeleteTest.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace Winter\Storm\Tests\Database\Traits;
+
+class SoftDeleteTest extends \DbTestCase
+{
+    protected $seeded = [];
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        $this->seeded = [
+            'posts' => [],
+            'categories' => []
+        ];
+
+        $this->createTables();
+        $this->seedTables();
+    }
+
+    protected function createTables()
+    {
+        $this->getBuilder()->create('posts', function ($table) {
+            $table->increments('id');
+            $table->string('title')->default('');
+            $table->timestamps();
+            $table->timestamp('deleted_at')->nullable();
+        });
+
+        $this->getBuilder()->create('categories', function ($table) {
+            $table->increments('id');
+            $table->string('name');
+            $table->timestamps();
+        });
+
+        $this->getBuilder()->create('categories_posts', function ($table) {
+            $table->primary(['post_id', 'category_id']);
+            $table->unsignedInteger('post_id');
+            $table->unsignedInteger('category_id');
+            $table->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    protected function seedTables()
+    {
+        $this->seeded['posts'][] = Post::create([
+            'title' => 'First Post',
+        ]);
+        $this->seeded['posts'][] = Post::create([
+            'title' => 'Second Post',
+        ]);
+
+        $this->seeded['categories'][] = Category::create([
+            'name' => 'Category 1'
+        ]);
+        $this->seeded['categories'][] = Category::create([
+            'name' => 'Category 2'
+        ]);
+
+        $this->seeded['posts'][0]->categories()->attach($this->seeded['categories'][0]);
+        $this->seeded['posts'][0]->categories()->attach($this->seeded['categories'][1]);
+
+        $this->seeded['posts'][1]->categories()->attach($this->seeded['categories'][0]);
+        $this->seeded['posts'][1]->categories()->attach($this->seeded['categories'][1]);
+    }
+
+    public function testDeleteAndRestore()
+    {
+        $post = Post::first();
+        $this->assertTrue($post->deleted_at === null);
+        $this->assertTrue($post->categories()->where('deleted_at', null)->count() === 2);
+
+        $post->delete();
+
+        $post = Post::withTrashed()->first();
+        $this->assertTrue($post->deleted_at != null);
+        $this->assertTrue($post->categories()->where('deleted_at', '!=', null)->count() === 2);
+        $post->restore();
+
+        $post = Post::first();
+        $this->assertTrue($post->deleted_at === null);
+        $this->assertTrue($post->categories()->where('deleted_at', null)->count() === 2);
+    }
+}
+
+class Post extends \Winter\Storm\Database\Model
+{
+    use \Winter\Storm\Database\Traits\SoftDelete;
+
+    public $table = 'posts';
+
+    public $fillable = ['title'];
+
+    protected $dates = [
+        'created_at',
+        'updated_at',
+        'deleted_at',
+    ];
+
+    public $belongsToMany = [
+        'categories' => [
+            Category::class,
+            'table'      => 'categories_posts',
+            'key'        => 'post_id',
+            'otherKey'   => 'category_id',
+            'softDelete' => true,
+        ],
+    ];
+}
+
+class Category extends \Winter\Storm\Database\Model
+{
+    public $table = 'categories';
+
+    public $fillable = ['name'];
+
+    protected $dates = [
+        'created_at',
+        'updated_at',
+    ];
+
+    public $belongsToMany = [
+        'posts' => [
+            Post::class,
+            'table'     => 'categories_posts',
+            'key'       => 'category_id',
+            'otherKey'  => 'post_id',
+        ],
+    ];
+}