Add sync and toggle relation helper

Author: florianJacques

src/Relations/BelongsToMany.php

@@ -4,16 +4,16 @@
 
 namespace MongoDB\Laravel\Relations;
 
+use BackedEnum;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Collection;
+use \Illuminate\Support\Collection as BaseCollection;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsToMany as EloquentBelongsToMany;
 use Illuminate\Support\Arr;
 
 use function array_diff;
-use function array_keys;
 use function array_map;
-use function array_merge;
 use function array_values;
 use function assert;
 use function count;
@@ -107,8 +107,35 @@ public function create(array $attributes = [], array $joining = [], $touch = tru
         return $instance;
     }
 
-    /** @inheritdoc */
-    public function sync($ids, $detaching = true)
+    /**
+     * Format the sync / toggle record list so that it is keyed by ID.
+     *
+     * @param  array  $records
+     * @return array
+     */
+    protected function formatRecordsList($records): array
+    {
+        //Support for an object type id.
+        //Removal of attribute management because there is no pivot table
+        return collect($records)->map(function ($id) {
+            if ($id instanceof BackedEnum) {
+                $id = $id->value;
+            }
+
+            return $id;
+        })->all();
+    }
+
+    /**
+     * Toggles a model (or models) from the parent.
+     *
+     * Each existing model is detached, and non existing ones are attached.
+     *
+     * @param  mixed  $ids
+     * @param  bool  $touch
+     * @return array
+     */
+    public function toggle($ids, $touch = true)
     {
         $changes = [
             'attached' => [],
@@ -130,25 +157,95 @@ public function sync($ids, $detaching = true)
             false => $this->parent->{$this->relationName} ?: [],
         };
 
-        if ($current instanceof Collection) {
+        // Support Base Collection
+        if ($current instanceof BaseCollection) {
             $current = $this->parseIds($current);
         }
 
+        $current = Arr::wrap($current);
         $records = $this->formatRecordsList($ids);
 
-        $current = Arr::wrap($current);
+        $detach = array_values(array_intersect($current, $records));
 
-        $detach = array_diff($current, array_keys($records));
+        if (count($detach) > 0) {
+            $this->detach($detach, false);
+
+            $changes['detached'] = (array) array_map(function ($v) {
+                return is_numeric($v) ? (int) $v : (string) $v;
+            }, $detach);
+        }
+
+        // Finally, for all of the records which were not "detached", we'll attach the
+        // records into the intermediate table. Then, we will add those attaches to
+        // this change list and get ready to return these results to the callers.
+        $attach = array_values(array_diff($records, $current));
+
+        if (count($attach) > 0) {
+            $this->attach($attach, [], false);
+
+            $changes['attached'] = (array) array_map(function ($v) {
+                return $this->castKey($v);
+            }, $attach);
+        }
+
+        // Once we have finished attaching or detaching the records, we will see if we
+        // have done any attaching or detaching, and if we have we will touch these
+        // relationships if they are configured to touch on any database updates.
+        if ($touch && (count($changes['attached']) ||
+                count($changes['detached']))) {
+
+            $this->parent->touch();
+            $this->newRelatedQuery()->whereIn($this->relatedKey, $ids)->touch();
+        }
+
+        return $changes;
+    }
 
-        // We need to make sure we pass a clean array, so that it is not interpreted
-        // as an associative array.
-        $detach = array_values($detach);
+
+    /**
+     * Sync the intermediate tables with a list of IDs or collection of models.
+     *
+     * @param  \Illuminate\Support\Collection|\Illuminate\Database\Eloquent\Model|array  $ids
+     * @param  bool  $detaching
+     * @return array
+     */
+    public function sync($ids, $detaching = true)
+    {
+        $changes = [
+            'attached' => [],
+            'detached' => [],
+            'updated' => [],
+        ];
+
+        if ($ids instanceof Collection) {
+            $ids = $this->parseIds($ids);
+        } elseif ($ids instanceof Model) {
+            $ids = $this->parseIds($ids);
+        }
+
+        // First we need to attach any of the associated models that are not currently
+        // in this joining table. We'll spin through the given IDs, checking to see
+        // if they exist in the array of current ones, and if not we will insert.
+        $current = match ($this->parent instanceof \MongoDB\Laravel\Eloquent\Model) {
+            true => $this->parent->{$this->relatedPivotKey} ?: [],
+            false => $this->parent->{$this->relationName} ?: [],
+        };
+
+        // Support Base Collection
+        if ($current instanceof BaseCollection) {
+            $current = $this->parseIds($current);
+        }
+
+        $current = Arr::wrap($current);
+        $records = $this->formatRecordsList($ids);
+
+        $detach = array_values(array_diff($current, $records));
 
         // Next, we will take the differences of the currents and given IDs and detach
         // all of the entities that exist in the "current" array but are not in the
         // the array of the IDs given to the method which will complete the sync.
         if ($detaching && count($detach) > 0) {
-            $this->detach($detach);
+            $this->detach($detach, false);
 
             $changes['detached'] = (array) array_map(function ($v) {
                 return is_numeric($v) ? (int) $v : (string) $v;
@@ -158,13 +255,18 @@ public function sync($ids, $detaching = true)
         // Now we are finally ready to attach the new records. Note that we'll disable
         // touching until after the entire operation is complete so we don't fire a
         // ton of touch operations until we are totally done syncing the records.
-        $changes = array_merge(
-            $changes,
-            $this->attachNew($records, $current, false),
-        );
+        foreach ($records as $id) {
+            // Only non strict check if exist no update s possible beacause no attributtes
+            if (!in_array($id, $current)) {
+                $this->attach($id, [], false);
+                $changes['attached'][] = $this->castKey($id);
+            }
+        }
 
-        if (count($changes['attached']) || count($changes['updated'])) {
-            $this->touchIfTouching();
+        if ((count($changes['attached']) || count($changes['detached']))) {
+            $touches = array_merge($detach, $records);
+            $this->parent->touch();
+            $this->newRelatedQuery()->whereIn($this->relatedKey, $touches)->touch();
         }
 
         return $changes;
@@ -207,7 +309,7 @@ public function attach($id, array $attributes = [], $touch = true)
             } else {
                 $id = (array) $id;
             }
-            
+
             $this->parent->push($this->relatedPivotKey, $id, true);
         } else {
             $instance = new $this->related();
@@ -220,13 +322,16 @@ public function attach($id, array $attributes = [], $touch = true)
             return;
         }
 
-        $this->touchIfTouching();
+        $this->parent->touch();
+        $this->newRelatedQuery()->whereIn($this->relatedKey, (array) $id);
     }
 
     /** @inheritdoc */
     public function detach($ids = [], $touch = true)
     {
-        if ($ids instanceof Model) {
+        if ($ids instanceof Collection) {
+            $ids = $this->parseIds($ids);
+        } elseif ($ids instanceof Model) {
             $ids = $this->parseIds($ids);
         }
 
@@ -247,6 +352,7 @@ public function detach($ids = [], $touch = true)
         } else {
             $value = $this->parent->{$this->relationName}
                 ->filter(fn ($rel) => ! in_array($rel->{$this->relatedKey}, $ids));
+
             $this->parent->setRelation($this->relationName, $value);
         }
 
@@ -261,7 +367,8 @@ public function detach($ids = [], $touch = true)
         $query->pull($this->foreignPivotKey, $this->parent->{$this->parentKey});
 
         if ($touch) {
-            $this->touchIfTouching();
+            $this->parent->touch();
+            $query->touch();
         }
 
         return count($ids);