Can someone help me how to set this up in Laravel - Or rather correct me

[user3470]

Setting Up Loupe Search in Laravel - Complete Guide

1. Installation

First, install the Loupe package via Composer:

composer require loupe/loupe

2. Create Service Provider

Create a new service provider:

php artisan make:provider LoupeServiceProvider

Update the service provider (app/Providers/LoupeServiceProvider.php):

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Loupe\Loupe\Configuration;
use Loupe\Loupe\Loupe;
use App\Models\Product;

class LoupeServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->singleton(Loupe::class, function ($app) {
            $product = new Product();

            $configuration = Configuration::create()
                   ->withPrimaryKey('uuid') // optional, by default it's 'id'
                ->withSearchableAttributes($product->getSearchableKeys()) // Dynamically fetched
                ->withFilterableAttributes($product->getFilterableKeys()) // Dynamically fetched
                ->withSortableAttributes($product->getSortableKeys());   // Dynamically fetched

            return new Loupe($configuration);
        });
    }
}

Register the provider in config/app.php:

'providers' => [
    // ...
    App\Providers\LoupeServiceProvider::class,
],

---

3. Add Dynamic Key Methods to Your Model

Update your model to dynamically return searchable, filterable, and sortable keys. Here's an example for the Product model:

<?php

namespace App\Models;

use App\Traits\Searchable;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    use Searchable;

    protected $fillable = [
        'name',
        'description',
        'price',
        'category',
    ];

    protected $casts = [
        'price' => 'float',
    ];

    public function toSearchableArray(): array
    {
        $this->load(['shop', 'category']);

        $index = [
            "category" => optional($this->category)->name,
            "tags" => $this->tags,
            "name" => $this->name,
            "brand" => $this->brand,
            "description" => $this->description,
            "google_product_category" => $this->g_category,
        ];

        return $index;
    }

    public function getSearchableKeys(): array
    {
        return array_keys($this->toSearchableArray());
    }

    public function getFilterableKeys(): array
    {
        return ['category', 'price'];
    }

    public function getSortableKeys(): array
    {
        return ['name', 'price', 'created_at'];
    }
}

---

4. Create Searchable Trait

Add a trait to handle the indexing and searching logic:

<?php

namespace App\Traits;

use Loupe\Loupe\Loupe;
use Loupe\Loupe\SearchParameters;

trait Searchable
{
    protected static function getLoupeInstance(): Loupe
    {
        return app(Loupe::class);
    }

    protected static function booted()
    {
        static::created(function ($model) {
            self::getLoupeInstance()->addDocument($model->toSearchableArray());
        });

        static::updated(function ($model) {
            self::getLoupeInstance()->addDocument($model->toSearchableArray());
        });

        static::deleted(function ($model) {
            self::getLoupeInstance()->deleteDocument($model->id);
        });
    }

    public static function search(?string $query = null, array $options = []): array
    {
        $searchParameters = SearchParameters::create();

        if ($query) {
            $searchParameters = $searchParameters->withQuery($query);
        }

        if (isset($options['filters'])) {
            $searchParameters = $searchParameters->withFilter($options['filters']);
        }

        if (isset($options['sort'])) {
            $searchParameters = $searchParameters->withSort($options['sort']);
        }

        if (isset($options['page'])) {
            $searchParameters = $searchParameters->withPage((int) $options['page']);
        }

        if (isset($options['per_page'])) {
            $searchParameters = $searchParameters->withHitsPerPage((int) $options['per_page']);
        }

        return self::getLoupeInstance()->search($searchParameters);
    }
}

---

5. Create Reindex Command

Create a new command:

php artisan make:command ReindexProducts

Update the command (app/Console/Commands/ReindexProducts.php):

<?php

namespace App\Console\Commands;

use App\Models\Product;
use Illuminate\Console\Command;
use Loupe\Loupe\Loupe;

class ReindexProducts extends Command
{
    protected $signature = 'loupe:reindex 
                          {--chunk=500 : The number of records to process at once}
                          {--fresh : Whether to clear the index before reindexing}';

    protected $description = 'Reindex all products in Loupe search';

    public function handle(Loupe $loupe)
    {
        $this->info('Starting product reindexing...');

        $count = Product::count();
        if ($count === 0) {
            $this->warn('No products found to index.');
            return;
        }

        if ($this->option('fresh')) {
            // Add logic for clearing the index if needed
            $this->info('Cleared existing index.');
        }

        $bar = $this->output->createProgressBar($count);
        $bar->start();

        Product::query()
            ->chunk($this->option('chunk'), function ($products) use ($loupe, $bar) {
                $documents = $products->map->toSearchableArray()->toArray();
                $loupe->addDocuments($documents);
                $bar->advance(count($documents));
            });

        $bar->finish();
        $this->newLine();
        $this->info('Reindexing complete!');
    }
}

Register the command in app/Console/Kernel.php:

protected $commands = [
    \App\Console\Commands\ReindexProducts::class,
];

---

6. Usage

Initial Indexing

After setup, index your existing products:

# Basic reindex
php artisan loupe:reindex

# Reindex with a custom chunk size
php artisan loupe:reindex --chunk=1000

# Clear the index before reindexing
php artisan loupe:reindex --fresh

---

Searching Products

Basic search:

$results = Product::search('laptop');

Advanced search with options:

$results = Product::search('laptop', [
    'filters' => 'price < 1000 AND category = "Electronics"',
    'sort' => ['price:asc'],
    'page' => 1,
    'per_page' => 20,
]);

---

Deployment

Add to your deployment script:

php artisan down
php artisan migrate
php artisan loupe:reindex --fresh
php artisan up

---

7. Features Included

• Dynamic searchable, filterable, and sortable keys
• Automatic indexing on model create/update/delete
• Full-text search with filters, sorting, and pagination
• Bulk reindexing with progress bar
• Configurable chunk size for large datasets
• Laravel service container integration

---

8. Troubleshooting

If you encounter issues:

1. Verify your toSearchableArray() keys match your model attributes.
2. Check that LoupeServiceProvider correctly fetches keys from the model.
3. Use --fresh to clear the index before reindexing.
4. Check Laravel logs for errors (storage/logs/laravel.log).

[user3470]

Help needed

Update the service provider (app/Providers/LoupeServiceProvider.php):
Getting error:

Expected type 'Loupe\Loupe\Internal\Engine'. Found 'Loupe\Loupe\Configuration'
@var \Loupe\Loupe\Configuration $configuration

[daun]

You'll need to use the factory class for creating Loupe instances, and give it a separate data directory for each index to store data in.

use Loupe\Loupe\Configuration;
use Loupe\Loupe\LoupeFactory;

$configuration = Configuration::create()->withPrimaryKey('uuid');
$loupe = (new LoupeFactory())->create(storage_path('app/loupe/products'), $configuration);