Set typemap on cursor, only root._id is mapped

Author: GromNaN

Diff for: src/Scout/ScoutEngine.php

@@ -66,6 +66,8 @@ final class ScoutEngine extends Engine
         ],
     ];
 
+    private const TYPEMAP = ['root' => 'object', 'document' => 'bson', 'array' => 'bson'];
+
     public function __construct(
         private Database $database,
         private bool $softDelete,
@@ -96,28 +98,42 @@ public function update($models)
 
         $bulk = [];
         foreach ($models as $model) {
+            assert($model instanceof Model && method_exists($model, 'toSearchableArray'), new LogicException(sprintf('Model "%s" must use "%s" trait', $model::class, Searchable::class)));
+
             $searchableData = $model->toSearchableArray();
             $searchableData = self::serialize($searchableData);
 
-            if ($searchableData) {
-                unset($searchableData['_id']);
-
-                $searchableData = array_merge($searchableData, $model->scoutMetadata());
-                if (isset($searchableData['__soft_deleted'])) {
-                    $searchableData['__soft_deleted'] = (bool) $searchableData['__soft_deleted'];
-                }
-
+            // Skip/remove the model if it doesn't provide any searchable data
+            if (! $searchableData) {
                 $bulk[] = [
-                    'updateOne' => [
+                    'deleteOne' => [
                         ['_id' => $model->getScoutKey()],
-                        [
-                            '$setOnInsert' => ['_id' => $model->getScoutKey()],
-                            '$set' => $searchableData,
-                        ],
-                        ['upsert' => true],
                     ],
                 ];
+
+                continue;
             }
+
+            unset($searchableData['_id']);
+
+            $searchableData = array_merge($searchableData, $model->scoutMetadata());
+
+            /** Convert the __soft_deleted set by {@see Searchable::pushSoftDeleteMetadata()}
+             * into a boolean for efficient storage and indexing. */
+            if (isset($searchableData['__soft_deleted'])) {
+                $searchableData['__soft_deleted'] = (bool) $searchableData['__soft_deleted'];
+            }
+
+            $bulk[] = [
+                'updateOne' => [
+                    ['_id' => $model->getScoutKey()],
+                    [
+                        '$setOnInsert' => ['_id' => $model->getScoutKey()],
+                        '$set' => $searchableData,
+                    ],
+                    ['upsert' => true],
+                ],
+            ];
         }
 
         $this->getIndexableCollection($models)->bulkWrite($bulk);
@@ -133,7 +149,7 @@ public function update($models)
     #[Override]
     public function delete($models): void
     {
-        assert($models instanceof Collection, new TypeError(sprintf('Argument #1 ($models) must be of type %s, %s given', Collection::class, get_debug_type($models))));
+        assert($models instanceof EloquentCollection, new TypeError(sprintf('Argument #1 ($models) must be of type %s, %s given', Collection::class, get_debug_type($models))));
 
         if ($models->isEmpty()) {
             return;
@@ -149,7 +165,7 @@ public function delete($models): void
      *
      * @see Engine::search()
      *
-     * @return mixed
+     * @return array
      */
     #[Override]
     public function search(Builder $builder)
@@ -158,14 +174,14 @@ public function search(Builder $builder)
     }
 
     /**
-     * Perform the given search on the engine.
+     * Perform the given search on the engine with pagination.
      *
      * @see Engine::paginate()
      *
      * @param int $perPage
      * @param int $page
      *
-     * @return mixed
+     * @return array
      */
     #[Override]
     public function paginate(Builder $builder, $perPage, $page)
@@ -182,20 +198,21 @@ public function paginate(Builder $builder, $perPage, $page)
     /**
      * Perform the given search on the engine.
      */
-    protected function performSearch(Builder $builder, ?int $offset = null): array
+    private function performSearch(Builder $builder, ?int $offset = null): array
     {
         $collection = $this->getSearchableCollection($builder->model);
 
         if ($builder->callback) {
-            $result = call_user_func(
+            $cursor = call_user_func(
                 $builder->callback,
                 $collection,
                 $builder->query,
                 $offset,
             );
-            assert($result instanceof CursorInterface, new LogicException(sprintf('The search builder closure must return a MongoDB cursor, %s returned', get_debug_type($result))));
+            assert($cursor instanceof CursorInterface, new LogicException(sprintf('The search builder closure must return a MongoDB cursor, %s returned', get_debug_type($cursor))));
+            $cursor->setTypeMap(self::TYPEMAP);
 
-            return $result->toArray();
+            return $cursor->toArray();
         }
 
         $compound = [
@@ -270,11 +287,10 @@ protected function performSearch(Builder $builder, ?int $offset = null): array
             $pipeline[] = ['$limit' => $builder->limit];
         }
 
-        $options = [
-            'typeMap' => ['root' => 'array', 'document' => 'array', 'array' => 'array'],
-        ];
+        $cursor = $collection->aggregate($pipeline);
+        $cursor->setTypeMap(self::TYPEMAP);
 
-        return $collection->aggregate($pipeline, $options)->toArray();
+        return $cursor->toArray();
     }
 
     /**
@@ -539,6 +555,6 @@ private function wait(Closure $callback): void
             sleep(1);
         }
 
-        throw new MongoDBRuntimeException('Atlas search index operation time out');
+        throw new MongoDBRuntimeException(sprintf('Atlas search index operation time out after %s seconds', self::WAIT_TIMEOUT_SEC));
     }
 }

Diff for: tests/AtlasSearchTest.php

@@ -14,12 +14,11 @@
 
 use function array_map;
 use function assert;
-
 use function mt_getrandmax;
 use function rand;
 use function range;
-use function srand;
 use function sort;
+use function srand;
 use function usleep;
 use function usort;
 

Diff for: tests/Scout/ScoutEngineTest.php

@@ -27,7 +27,7 @@
 /** Unit tests that do not require an Atlas Search cluster */
 class ScoutEngineTest extends TestCase
 {
-    private const EXPECTED_SEARCH_OPTIONS = ['typeMap' => ['root' => 'array', 'document' => 'array', 'array' => 'array']];
+    private const EXPECTED_TYPEMAP = ['root' => 'object', 'document' => 'bson', 'array' => 'bson'];
 
     /** @param callable(): Builder $builder  */
     #[DataProvider('provideSearchPipelines')]
@@ -40,13 +40,16 @@ public function testSearch(Closure $builder, array $expectedPipeline): void
             ->with('collection_searchable')
             ->andReturn($collection);
         $cursor = m::mock(CursorInterface::class);
+        $cursor->shouldReceive('setTypeMap')->once()->with(self::EXPECTED_TYPEMAP);
         $cursor->shouldReceive('toArray')->once()->with()->andReturn($data);
 
+        $collection->shouldReceive('getCollectionName')
+            ->zeroOrMoreTimes()
+            ->andReturn('collection_searchable');
         $collection->shouldReceive('aggregate')
             ->once()
-            ->withArgs(function ($pipeline, $options) use ($expectedPipeline) {
+            ->withArgs(function ($pipeline) use ($expectedPipeline) {
                 self::assertEquals($expectedPipeline, $pipeline);
-                self::assertEquals(self::EXPECTED_SEARCH_OPTIONS, $options);
 
                 return true;
             })
@@ -295,10 +298,11 @@ function () {
             fn () => new Builder(new SearchableModel(), 'query', callback: function (...$args) {
                 $this->assertCount(3, $args);
                 $this->assertInstanceOf(Collection::class, $args[0]);
+                $this->assertSame('collection_searchable', $args[0]->getCollectionName());
                 $this->assertSame('query', $args[1]);
                 $this->assertNull($args[2]);
 
-                return $args[0]->aggregate(['pipeline'], self::EXPECTED_SEARCH_OPTIONS);
+                return $args[0]->aggregate(['pipeline']);
             }),
             ['pipeline'],
         ];
@@ -383,11 +387,10 @@ public function testPaginate()
                     ],
                 ], $args[0]);
 
-                $this->assertSame(self::EXPECTED_SEARCH_OPTIONS, $args[1]);
-
                 return true;
             })
             ->andReturn($cursor);
+        $cursor->shouldReceive('setTypeMap')->once()->with(self::EXPECTED_TYPEMAP);
         $cursor->shouldReceive('toArray')
             ->once()
             ->with()