Using ViewModels to transform data before Indexing

[tao]

In order to use the MeiliSearch Geosearch you need to provide an array _geo with lat and lng fields. The default Statamic search transformer doesn't provide much flexibility in combining fields into this format.

One solution was to add a _geo field to Statamic collection which holds the lat and lng values separated by comma. So the transformer was easy to set up as follows:

             'transformers' => [
                '_geo' => function ($_geo) {
                    $latlng = explode(',', $_geo);
                    return [
                        '_geo' => [
                            'lat' => (float) $latlng[0],
                            'lng' => (float) $latlng[1]
                        ]
                    ];
                },

While this might work in some cases it could also be complicated for some users, especially if you don't want to store the coordinates as a comma separated field in your collection.

Another solution could be to call the collection ViewModel before inserting or updating data. To do so we may have to modify the following two methods: update and insert.

For example I have the following ViewModel which does a word count, the same example used in the Statamic documentation:

class BlogViewModel extends ViewModel
{
    public function data(): array
    {
        // Combine content blocks
        $html = collect($this->cascade->get('main_content'))
            ->implode('text', " ");

        // Remove HTML tags
        $content = strip_tags($html);

        // Calculate stats
        $character_count = strlen($content);
        $word_count      = str_word_count($content);
        $read_time       = ceil($word_count / 200);

        return [
            'character_count' => $character_count,
            'word_count'      => $word_count,
            'read_time'       => $read_time
        ];
    }
}

In the driver function you can call this manually as follows:

    public function update()
    {
        $this->deleteIndex();
        $this->createIndex();

        // Prepare documents for update
        $searchables = $this->searchables()->all()->map(function ($entry) {

            // use view model
            $cascade = (new Statamic\View\Cascade(request(), $entry->site(), $entry->toArray()));
            $view_model = $entry->collection()->cascade()->get('view_model');
            $view_model_data = (new $view_model($cascade))->data();

            return array_merge(
                $this->searchables()->fields($entry),
                $this->getDefaultFields($entry),
                $view_model_data,
            );
        });

        // Update documents
        $documents = new Documents($searchables);
        $this->insertDocuments($documents);

        return $this;
    }

And in the insert function we need to call it a bit differently

    public function insert($document)
    {
        // use view model
        $sites = new Statamic\Sites\Sites(config('statamic.sites'));
        $cascade = (new Statamic\View\Cascade(request(), $sites->get($document->locale()), $document->toArray()));
        $view_model = $document['view_model'];
        $view_model_data = (new $view_model($cascade))->data();

        $fields = array_merge(
            $this->searchables()->fields($document),
            $this->getDefaultFields($document),
            $view_model_data,
        );
        $this->getIndex()->updateDocuments([$fields]);
    }

However, now my word_count is included in the Search:

This could provide a lot more options for manipulating the data before inserting them into the Search Engine, however you may want to perform different transformations on the data for the search engine compared to the frontend views. We could potentially overcome this by trying to call a specialised search function in the ViewModel:

class BlogViewModel extends ViewModel
{
    public function data(): array
    {
        // transformations for front end
    }
    
    public function search(): array
    {
        // transformations for search engine
    }
}

So this same principle could be applied to include _geo required for MeiliSearch:

class DonutShopViewModel extends ViewModel
{
    public function search(): array
    {
        // get coordinates from entry cascade
        $lat, $lng = 0;
       
        return [
            '_geo' => [
                'lat'      => $lat,
                'lng'     => $lng
            ]
        ];
    }
}

And some safety checks might be necessary to only call the ViewModel on Entries and not Taxonomies, etc.