[Feature] Add MorphToMany support

src/Eloquent/HybridRelations.php

@@ -15,11 +15,16 @@
 use MongoDB\Laravel\Relations\HasOne;
 use MongoDB\Laravel\Relations\MorphMany;
 use MongoDB\Laravel\Relations\MorphTo;
+use MongoDB\Laravel\Relations\MorphToMany;
 
+use function array_pop;
 use function debug_backtrace;
+use function implode;
 use function is_subclass_of;
+use function preg_split;
 
 use const DEBUG_BACKTRACE_IGNORE_ARGS;
+use const PREG_SPLIT_DELIM_CAPTURE;
 
 /**
  * Cross-database relationships between SQL and MongoDB.
@@ -328,6 +333,125 @@ public function belongsToMany(
  );
  }
 
+ /**
+ * Define a morph-to-many relationship.
+ *
+ * @param string $related
+ * @param string $name
+ * @param null $table
+ * @param null $foreignPivotKey
+ * @param null $relatedPivotKey
+ * @param null $parentKey
+ * @param null $relatedKey
+ * @param null $relation
+ * @param bool $inverse
+ *
+ * @return \Illuminate\Database\Eloquent\Relations\MorphToMany
+ */
+ public function morphToMany(
+ $related,
+ $name,
+ $table = null,
+ $foreignPivotKey = null,
+ $relatedPivotKey = null,
+ $parentKey = null,
+ $relatedKey = null,
+ $relation = null,
+ $inverse = false,
+ ) {
+ // If no relationship name was passed, we will pull backtraces to get the
+ // name of the calling function. We will use that function name as the
+ // title of this relation since that is a great convention to apply.
+ if ($relation === null) {
+ $relation = $this->guessBelongsToManyRelation();
+ }
+
+ // Check if it is a relation with an original model.
+ if (! is_subclass_of($related, Model::class)) {
+ return parent::morphToMany(
+ $related,
+ $name,
+ $table,
+ $foreignPivotKey,
+ $relatedPivotKey,
+ $parentKey,
+ $relatedKey,
+ $relation,
+ $inverse,
+ );
+ }
+
+ $instance = new $related();
+
+ $foreignPivotKey = $foreignPivotKey ?: $name . '_id';
+ $relatedPivotKey = $relatedPivotKey ?: Str::plural($instance->getForeignKey());
+
+ // Now we're ready to create a new query builder for the related model and
+ // the relationship instances for this relation. This relation will set
+ // appropriate query constraints then entirely manage the hydration.
+ if (! $table) {
+ $words = preg_split('/(_)/u', $name, -1, PREG_SPLIT_DELIM_CAPTURE);
+ $lastWord = array_pop($words);
+ $table = implode('', $words) . Str::plural($lastWord);
+ }
+
+ return new MorphToMany(
+ $instance->newQuery(),
+ $this,
+ $name,
+ $table,
+ $foreignPivotKey,
+ $relatedPivotKey,
+ $parentKey ?: $this->getKeyName(),
+ $relatedKey ?: $instance->getKeyName(),
+ $relation,
+ $inverse,
+ );
+ }
+
+ /**
+ * Define a polymorphic, inverse many-to-many relationship.
+ *
+ * @param string $related
+ * @param string $name
+ * @param null $table
+ * @param null $foreignPivotKey
+ * @param null $relatedPivotKey
+ * @param null $parentKey
+ * @param null $relatedKey
+ *
+ * @return \Illuminate\Database\Eloquent\Relations\MorphToMany
+ */
+ public function morphedByMany(
+ $related,
+ $name,
+ $table = null,
+ $foreignPivotKey = null,
+ $relatedPivotKey = null,
+ $parentKey = null,
+ $relatedKey = null,
+ $relation = null,
+ ) {
+ $foreignPivotKey = $foreignPivotKey ?: Str::plural($this->getForeignKey());
+
+ // For the inverse of the polymorphic many-to-many relations, we will change
+ // the way we determine the foreign and other keys, as it is the opposite
+ // of the morph-to-many method since we're figuring out these inverses.
+ $relatedPivotKey = $relatedPivotKey ?: $name . '_id';
+
+ return $this->morphToMany(
+ $related,
+ $name,
+ $table,
+ $foreignPivotKey,
+ $relatedPivotKey,
+ $parentKey,
+ $relatedKey,
+ $relatedKey,
+ true,
+ );
+ }
+
  /** @inheritdoc */
  public function newEloquentBuilder($query)
  {

src/Helpers/QueriesRelationships.php

@@ -13,12 +13,15 @@
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Support\Collection;
 use MongoDB\Laravel\Eloquent\Model;
+use MongoDB\Laravel\Relations\MorphToMany;
 
 use function array_count_values;
 use function array_filter;
 use function array_keys;
 use function array_map;
 use function class_basename;
+use function collect;
+use function get_class;
 use function in_array;
 use function is_array;
 use function is_string;
@@ -114,13 +117,48 @@ public function addHybridHas(Relation $relation, $operator = '>=', $count = 1, $
  $not = ! $not;
  }
 
- $relations = $hasQuery->pluck($this->getHasCompareKey($relation));
+ $relations = match (true) {
+ $relation instanceof MorphToMany => $relation->getInverse() ?
+ $this->handleMorphedByMany($hasQuery, $relation) :
+ $this->handleMorphToMany($hasQuery, $relation),
+ default => $hasQuery->pluck($this->getHasCompareKey($relation))
+ };
 
  $relatedIds = $this->getConstrainedRelatedIds($relations, $operator, $count);
 
  return $this->whereIn($this->getRelatedConstraintKey($relation), $relatedIds, $boolean, $not);
  }
 
+ /**
+ * @param Builder $hasQuery
+ * @param Relation $relation
+ *
+ * @return Collection
+ */
+ private function handleMorphToMany($hasQuery, $relation)
+ {
+ // First we select the parent models that have a relation to our related model,
+ // Then extracts related model's ids from the pivot column
+ $hasQuery->where($relation->getTable() . '.' . $relation->getMorphType(), get_class($relation->getParent()));
+ $relations = $hasQuery->pluck($relation->getTable());
+ $relations = $relation->extractIds($relations->flatten(1)->toArray(), $relation->getForeignPivotKeyName());
+
+ return collect($relations);
+ }
+
+ /**
+ * @param Builder $hasQuery
+ * @param Relation $relation
+ *
+ * @return Collection
+ */
+ private function handleMorphedByMany($hasQuery, $relation)
+ {
+ $hasQuery->whereNotNull($relation->getForeignPivotKeyName());
+
+ return $hasQuery->pluck($relation->getForeignPivotKeyName())->flatten(1);
+ }
+
  /** @return string */
  protected function getHasCompareKey(Relation $relation)
  {