Add support for using $text operator in a aggregation with a filter

lib/Doctrine/ODM/MongoDB/Aggregation/Builder.php

@@ -14,6 +14,7 @@
 use GeoJson\Geometry\Point;
 use MongoDB\Collection;
 use OutOfRangeException;
+use stdClass;
 use TypeError;
 
 use function array_map;
@@ -264,6 +265,11 @@ public function getAggregation(array $options = []): IterableResult
      * @param bool $applyFilters Whether to apply filters on the aggregation
      * pipeline stage
      *
+     * For pipelines where the first stage is a $match stage, it will merge
+     * the document filters with the existing stage in a logical $and. This is
+     * required as $text operator can be used anywhere in the first $match stage
+     * or in the document filters.
+     *
      * For pipelines where the first stage is a $geoNear stage, it will apply
      * the document filters and discriminator queries to the query portion of
      * the geoNear operation. For all other pipelines, it prepends a $match stage
@@ -306,14 +312,20 @@ public function getPipeline(/* bool $applyFilters = true */): array
             return $pipeline;
         }
 
-        if ($this->getStage(0) instanceof Stage\GeoNear) {
+        if (isset($pipeline[0]['$geoNear'])) {
             $pipeline[0]['$geoNear']['query'] = $this->applyFilters($pipeline[0]['$geoNear']['query']);
 
             return $pipeline;
         }
 
+        if (isset($pipeline[0]['$match'])) {
+            $pipeline[0]['$match'] = $this->applyFilters($pipeline[0]['$match']);
+
+            return $pipeline;
+        }
+
         $matchExpression = $this->applyFilters([]);
-        if ($matchExpression !== []) {
+        if ((array) $matchExpression !== []) {
             array_unshift($pipeline, ['$match' => $matchExpression]);
         }
 
@@ -696,18 +708,22 @@ public function addStage(Stage $stage): Stage
     /**
      * Applies filters and discriminator queries to the pipeline
      *
-     * @param array<string, mixed> $query
+     * @param array<string, mixed>|stdClass $query
      *
-     * @return array<string, mixed>
+     * @return array<string, mixed>|stdClass
      */
-    private function applyFilters(array $query): array
+    private function applyFilters(array|stdClass $query): array|stdClass
     {
+        if (! is_array($query)) {
+            $query = (array) $query;
+        }
+
         $documentPersister = $this->getDocumentPersister();
 
         $query = $documentPersister->addDiscriminatorToPreparedQuery($query);
         $query = $documentPersister->addFilterToPreparedQuery($query);
 
-        return $query;
+        return $query === [] ? (object) $query : $query;
     }
 
     private function getDocumentPersister(): DocumentPersister

lib/Doctrine/ODM/MongoDB/Persisters/DocumentPersister.php

@@ -1029,9 +1029,6 @@ public function addFilterToPreparedQuery(array $preparedQuery): array
     {
         /* If filter criteria exists for this class, prepare it and merge
          * over the existing query.
-         *
-         * @todo Consider recursive merging in case the filter criteria and
-         * prepared query both contain top-level $and/$or operators.
          */
         $filterCriteria = $this->dm->getFilterCollection()->getFilterCriteria($this->class);
         if ($filterCriteria) {

tests/Doctrine/ODM/MongoDB/Tests/Aggregation/BuilderTest.php

@@ -368,6 +368,36 @@ public function testBuilderAppliesFilterAndDiscriminatorWithMatchStage(): void
         self::assertEquals($expectedPipeline, $builder->getPipeline());
     }
 
+    public function testBuilderMergeFilterAndDiscriminatorWithMatchStage(): void
+    {
+        $this->dm->getFilterCollection()->enable('testFilter');
+        $filter = $this->dm->getFilterCollection()->getFilter('testFilter');
+        $filter->setParameter('class', GuestServer::class);
+        $filter->setParameter('field', 'filtered');
+        $filter->setParameter('value', true);
+
+        $builder = $this->dm->createAggregationBuilder(GuestServer::class);
+        $builder
+            ->match()
+                ->text('Paul');
+
+        $expectedPipeline = [
+            [
+                '$match' => [
+                    '$and' => [
+                        [
+                            'stype' => 'server_guest',
+                            '$text' => ['$search' => 'Paul'],
+                        ],
+                        ['filtered' => true],
+                    ],
+                ],
+            ],
+        ];
+
+        self::assertEquals($expectedPipeline, $builder->getPipeline());
+    }
+
     public function testBuilderAppliesFilterAndDiscriminatorWithGeoNearStage(): void
     {
         $this->dm->getFilterCollection()->enable('testFilter');

tests/Doctrine/ODM/MongoDB/Tests/Aggregation/Stage/GeoNearTest.php

@@ -72,7 +72,7 @@ public function testLimitDoesNotCreateExtraStage(): void
             ->geoNear(0, 0)
             ->limit(1);
 
-        $stage = ['near' => [0, 0], 'spherical' => false, 'distanceField' => null, 'query' => [], 'num' => 1];
-        self::assertSame([['$geoNear' => $stage]], $builder->getPipeline());
+        $stage = ['near' => [0, 0], 'spherical' => false, 'distanceField' => null, 'query' => (object) [], 'num' => 1];
+        self::assertEquals([['$geoNear' => $stage]], $builder->getPipeline());
     }
 }

tests/Doctrine/ODM/MongoDB/Tests/Functional/FilterTest.php

@@ -334,4 +334,22 @@ public function testMultipleFiltersOnSameField(): void
          */
         self::assertEmpty($this->getUsernamesWithFindAll());
     }
+
+    public function testFilterOnMatchStageUsingTextOperator(): void
+    {
+        $this->dm->getDocumentCollection(User::class)->createIndex(['username' => 'text']);
+
+        $this->fc->enable('testFilter');
+        $testFilter = $this->fc->getFilter('testFilter');
+        $testFilter->setParameter('class', User::class);
+        $testFilter->setParameter('field', 'hits');
+        $testFilter->setParameter('value', 10);
+
+        $builder = $this->dm->createAggregationBuilder(User::class)
+            ->match()
+            ->field('username')
+            ->text('John');
+
+        self::assertCount(1, $builder->getAggregation()->execute());
+    }
 }