Added bulk indexing support

Author: babenkoivan

README.md

@@ -43,6 +43,7 @@ There are information about Elasticsearch installation and the package usage exa
 * Lots of different ways to implement your search algorithm: using [search rules](#search-rules) or a [raw search](#usage).
 * [Various filter types](#available-filters) to make a search query more specific.
 * [Zero downtime migration](#zero-downtime-migration) from an old index to a new index.
+* Bulk indexing, see [the configuration section](#configuration).
 
 ## Requirements
 
@@ -70,12 +71,15 @@ php artisan vendor:publish --provider="ScoutElastic\ScoutElasticServiceProvider"
 ```
 
 Then, set the driver setting to `elastic` in the `config/scout.php` file and configure the driver itself in the `config/scout_elastic.php` file.
-There are two available options:
+The available options are:
 
 Option | Description
 --- | ---
 client | A setting hash to build Elasticsearch client. More information you can find [here](https://www.elastic.co/guide/en/elasticsearch/client/php-api/current/_configuration.html#_building_the_client_from_a_configuration_hash). By default the host is set to `localhost:9200`.
 update_mapping | The option that specifies whether to update a mapping automatically or not. By default it is set to `true`.
+indexer | Set to `single` for the single document indexing and to `bulk` for the bulk document indexing. By default is set to `true`.
+
+Note, that if you use the bulk document indexing you'll probably want to change the chunk size, you can do that in the `config/scout.php` file.
 
 ## Index configurator
 
@@ -190,7 +194,7 @@ class MyModel extends Model
 Each searchable model represents an Elasticsearch type.
 By default a type name is the same as a table name, but you can set any type name you want through the `searchableAs` method.
 You can also specify fields which will be indexed by the driver through the `toSearchableArray` method.
-More information about these options you will find in [the scout official documentation](https://laravel.com/docs/5.4/scout#configuration).
+More information about these options you will find in [the scout official documentation](https://laravel.com/docs/5.5/scout#configuration).
 
 The last important option you can set in the `MyModel` class is the `$searchRules` property. 
 It allows you to set different search algorithms for a model. 
@@ -205,9 +209,19 @@ php artisan elastic:update-mapping App\\MyModel
 ## Usage
 
 Once you've created an index configurator, an Elasticsearch index itself and a searchable model, you are ready to go.
-Now you can [index](https://laravel.com/docs/5.4/scout#indexing) and [search](https://laravel.com/docs/5.4/scout#searching) data according to the documentation.
+Now you can [index](https://laravel.com/docs/5.5/scout#indexing) and [search](https://laravel.com/docs/5.5/scout#searching) data according to the documentation.
+
+Basic search usage example:
+
+```php
+App\MyModel::search('phone') 
+    ->where('color', 'red')
+    ->orderBy('price', 'asc')
+    ->take(10)
+    ->get();
+```
 
-In addition to standard functionality the package offers you the possibility to filter data in Elasticsearch without specifying query string:
+In addition to standard functionality the package offers you the possibility to filter data in Elasticsearch without specifying a query string:
 
 ```php
 App\MyModel::search('*')

config/scout_elastic.php

@@ -6,5 +6,6 @@
             env('SCOUT_ELASTIC_HOST', 'localhost:9200')
         ]
     ],
-    'update_mapping' => env('SCOUT_ELASTIC_UPDATE_MAPPING', true)
+    'update_mapping' => env('SCOUT_ELASTIC_UPDATE_MAPPING', true),
+    'indexer' => env('SCOUT_ELASTIC_INDEXER', 'single')
 ];

src/ElasticEngine.php

@@ -2,65 +2,59 @@
 
 namespace ScoutElastic;
 
-use Artisan;
+use Illuminate\Support\Facades\Artisan;
 use Laravel\Scout\Builder;
 use Laravel\Scout\Engines\Engine;
 use ScoutElastic\Builders\SearchBuilder;
 use ScoutElastic\Facades\ElasticClient;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\Model;
-use ScoutElastic\Payloads\DocumentPayload;
+use ScoutElastic\Indexers\IndexerInterface;
 use ScoutElastic\Payloads\TypePayload;
 use stdClass;
 
 class ElasticEngine extends Engine
 {
-    protected $updateMapping = false;
+    protected $indexer;
 
-    public function __construct()
+    protected $updateMapping;
+
+    static protected $updatedMappings = [];
+
+    public function __construct(IndexerInterface $indexer, $updateMapping)
     {
-        $this->updateMapping = config('scout_elastic.update_mapping');
+        $this->indexer = $indexer;
+
+        $this->updateMapping = $updateMapping;
     }
 
     public function update($models)
     {
-        $models->each(function ($model) {
-            if ($this->updateMapping) {
-                Artisan::call(
-                    'elastic:update-mapping',
-                    ['model' => get_class($model)]
-                );
-            }
-
-            $array = $model->toSearchableArray();
-
-            if (empty($array)) {
-                return true;
-            }
+        if ($this->updateMapping) {
+            $self = $this;
 
-            $indexConfigurator = $model->getIndexConfigurator();
+            $models->each(function ($model) use ($self) {
+                $modelClass = get_class($model);
 
-            $payload = (new DocumentPayload($model))
-                ->set('body', $array);
+                if (in_array($modelClass, $self::$updatedMappings)) {
+                    return true;
+                }
 
-            if (in_array(Migratable::class, class_uses_recursive($indexConfigurator))) {
-                $payload->useAlias('write');
-            }
+                Artisan::call(
+                    'elastic:update-mapping',
+                    ['model' => $modelClass]
+                );
 
-            ElasticClient::index($payload->get());
-        });
+                $self::$updatedMappings[] = $modelClass;
+            });
+        }
 
-        $this->updateMapping = false;
+        $this->indexer->update($models);
     }
 
     public function delete($models)
     {
-        $models->each(function ($model) {
-            $payload = (new DocumentPayload($model))
-                ->get();
-
-            ElasticClient::delete($payload);
-        });
+        $this->indexer->delete($models);
     }
 
     protected function buildSearchQueryPayload(Builder $builder, $queryPayload, array $options = [])

src/Indexers/BulkIndexer.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace ScoutElastic\Indexers;
+
+use Illuminate\Database\Eloquent\Collection;
+use ScoutElastic\Facades\ElasticClient;
+use ScoutElastic\Migratable;
+use ScoutElastic\Payloads\RawPayload;
+
+class BulkIndexer implements IndexerInterface
+{
+    public function update(Collection $models)
+    {
+        $bulkPayload = new RawPayload();
+
+        $models->each(function ($model) use ($bulkPayload) {
+            $modelData = $model->toSearchableArray();
+
+            if (empty($modelData)) {
+                return true;
+            }
+
+            $indexConfigurator = $model->getIndexConfigurator();
+
+            $actionPayload = (new RawPayload())
+                ->set('index._type', $model->searchableAs())
+                ->set('index._id', $model->getKey());
+
+            if (in_array(Migratable::class, class_uses_recursive($indexConfigurator))) {
+                $actionPayload->set('index._index', $indexConfigurator->getWriteAlias());
+            } else {
+                $actionPayload->set('index._index', $indexConfigurator->getName());
+            }
+
+            $bulkPayload->add('body', $actionPayload->get())
+                ->add('body', $modelData);
+        });
+
+        ElasticClient::bulk($bulkPayload->get());
+    }
+
+    public function delete(Collection $models)
+    {
+        $bulkPayload = new RawPayload();
+
+        $models->each(function ($model) use ($bulkPayload) {
+            $indexConfigurator = $model->getIndexConfigurator();
+
+            $actionPayload = (new RawPayload())
+                ->set('delete._index', $indexConfigurator->getName())
+                ->set('delete._type', $model->searchableAs())
+                ->set('delete._id', $model->getKey());
+
+            $bulkPayload->add('body', $actionPayload->get());
+        });
+
+        ElasticClient::bulk($bulkPayload->get());
+    }
+}

src/Indexers/IndexerInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace ScoutElastic\Indexers;
+
+use Illuminate\Database\Eloquent\Collection;
+
+interface IndexerInterface
+{
+    public function update(Collection $models);
+
+    public function delete(Collection $models);
+}

src/Indexers/SingleIndexer.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace ScoutElastic\Indexers;
+
+use Illuminate\Database\Eloquent\Collection;
+use ScoutElastic\Facades\ElasticClient;
+use ScoutElastic\Migratable;
+use ScoutElastic\Payloads\DocumentPayload;
+
+class SingleIndexer implements IndexerInterface
+{
+    public function update(Collection $models)
+    {
+        $models->each(function ($model) {
+            $modelData = $model->toSearchableArray();
+
+            if (empty($modelData)) {
+                return true;
+            }
+
+            $indexConfigurator = $model->getIndexConfigurator();
+
+            $payload = (new DocumentPayload($model))
+                ->set('body', $modelData);
+
+            if (in_array(Migratable::class, class_uses_recursive($indexConfigurator))) {
+                $payload->useAlias('write');
+            }
+
+            ElasticClient::index($payload->get());
+        });
+    }
+
+    public function delete(Collection $models)
+    {
+        $models->each(function ($model) {
+            $payload = (new DocumentPayload($model))
+                ->get();
+
+            ElasticClient::delete($payload);
+        });
+    }
+}

src/Payloads/RawPayload.php

@@ -24,6 +24,32 @@ public function setIfNotEmpty($key, $value)
         return $this->set($key, $value);
     }
 
+    public function add($key, $value)
+    {
+        if (!is_null($key)) {
+            $currentValue = array_get($this->payload, $key, []);
+
+            if (!is_array($currentValue)) {
+                $currentValue = array_wrap($currentValue);
+            }
+
+            $currentValue[] = $value;
+
+            array_set($this->payload, $key, $currentValue);
+        }
+
+        return $this;
+    }
+
+    public function addIfNotEmpty($key, $value)
+    {
+        if (empty($value)) {
+            return $this;
+        }
+
+        return $this->add($key, $value);
+    }
+
     public function get($key = null)
     {
         return array_get($this->payload, $key);

src/ScoutElasticServiceProvider.php

@@ -5,6 +5,7 @@
 use Config;
 use Illuminate\Support\ServiceProvider;
 use Elasticsearch\ClientBuilder;
+use InvalidArgumentException;
 use ScoutElastic\Console\ElasticIndexCreateCommand;
 use ScoutElastic\Console\ElasticIndexDropCommand;
 use ScoutElastic\Console\ElasticIndexUpdateCommand;
@@ -39,7 +40,19 @@ public function boot()
 
         $this->app->make(EngineManager::class)
             ->extend('elastic', function () {
-                return new ElasticEngine();
+                $indexerType = config('scout_elastic.indexer', 'single');
+                $updateMapping = config('scout_elastic.update_mapping', true);
+
+                $indexerClass = '\\ScoutElastic\\Indexers\\'.ucfirst($indexerType).'Indexer';
+
+                if (!class_exists($indexerClass)) {
+                    throw new InvalidArgumentException(sprintf(
+                        'The %s indexer doesn\'t exist.',
+                        $indexerType
+                    ));
+                }
+
+                return new ElasticEngine(new $indexerClass(), $updateMapping);
             });
     }