Bonjour à tous,

j'ai un service de recherche utilisant Elasticsearch. Ce service construit la requête en fonction des paramètres envoyés par l'utilisateur.
Chaque paramètre est associé à un type particulier. Afin de rendre mon code plus flexible, dans le cas ou un nouveau type devrait être créé, je souhaite déléguer, le traitement pour chaque type dans une classe dédiée. Problème, les différents types ne possèdent pas tous les même dépendances.

namespace App\Recherche\Elasticsearch;

use App\Recherche\Elasticsearch\FieldType\FulltextType;
use App\Recherche\Elasticsearch\FieldType\StringType;

class InputFieldAnalyzer
{
    const INPUTS_RECHERCHEABLES = [
        'fulltext' => FulltextType::class,
        'ville' => StringType::class
        // et ainsi de suite
    ];

    public function __construct(RequestStack $requestStack, ParameterBagInterface $params, TranslatorInterface $translator)
    {
        $this->requestStack = $requestStack;
        $this->params = $params;
        $this->translator = $translator;
    }

    public function analyze(array $fields)
    {
        foreach ($fields as $field => $value) {
            
            if (!in_array($field, array_keys(self::INPUTS_RECHERCHEABLES)))
                continue;
            
            if (is_array($value)) {
                $value = array_filter($value, 'strlen');
            } else {
                $value = trim($value);
            }
           // ICI Je souhaiterais appeler mes objets `types` avec les dépendances souhaitées.
           // FulltextType a besoin de la session
           // StringType n'a pas besoin de la session
           // Si plus tard je souhaite ajouter un type, il faudrait juste créer la classe corespondante,
           // ajouter un use et déclarer le champ dans INPUTS_RECHERCHEABLES 
           // sans modifier le fonctionnement de cette méthode.
        }
    }
}

Quelqu'un aurait il une solution pour effectuer cela ? Je me suis inspiré de symfony et des formulaires, où dans le formBuilder on peut ajouter des champs custom si on le souhaite.

J'ai trouvé une solution qui consiste à utiliser le mot clé tagged_locator dans le fichier services.yaml.
Voici un exemple

FooInterface:

interface FooInterface
{
    public function whoAmI(): string;
}

Services
Certains services nécessitant d'être injectés et qui implémente FooInterface

class FooOneService implements FooInterface { }
class FooTwoService implements FooInterface { }

Le service ayant besoin de ceux implémentant FooInterface

class Bar
{
    /**
     * @var \Symfony\Component\DependencyInjection\ServiceLocator
     */
    private $service_locator;

    public function __construct(ServiceLocator $service_locator) {
        $this->service_locator = $service_locator;
    }

    public function handle(): string {
        /** @var \App\Test\FooInterface $service */
        $service = $this->service_locator->get(FooOneService::class);

        return $service->whoAmI();
    }
}

Configuration
la configuration requise

services:
  _instanceof:
    App\Test\FooInterface:
      tags: ['test_foo_tag']
      lazy: true
    
  App\Test\Bar:
      arguments:
        - !tagged_locator
          tag: 'test_foo_tag'